Python网络编程（小白一看就懂）

缺乏、安全感 2022-10-08 05:47 187阅读 0赞

# Python网络编程（小白一看就懂） #

## 一、网络编程基础概念 ##

#### 1. mac地址与ip地址 ####

举个例子，在大学校园，找到名叫Lucy的男神可以用**学号**，脱离了校园，你要找到Lucy男神，你就要通过**身份证号**，这里**学号**是临时的编号，变化的，出了校园就不可用了；**身份证号**是唯一标识，不变的，在哪里都能找到。

在计算机中，也有类似的概念，不变的是mac地址，能够唯一标识你这台机器；变化的是ip地址，能够更方便的找到你的机器。（可以类比生活中运送快递）

#### 1.1 ip地址 ####

**ipv4协议**：规定ip地址是由四位点分十进制数组成，每一位都是八位二进制（表示的范围是0 ~ 255），所以ip地址范围0.0.0.0 ~ 255.255.255.255

**公网地址**：需要我们自己申请购买的地址

**内网地址**：保留字段，192.168.0.0 ~ 192.168.255.255 和 172.16.0.0 ~ 172.31.255.255 和 10.0.0.0 ~ 10.255.255.255，在这些范围内的地址都是内网地址。

访问公网地址用的是路由器，访问内网地址用的是交换机。

有一个特殊的ip地址，127.0.0.1 本地回环地址。一般都是做测试的时候使用。

查看自己的ip地址：在cmd中输入ipconfig查看。linux和mac通过ifconfig。

比如，172.168.14.0这个网段内，最多能有254台机器，还有一台是网关ip。因为ip地址中0用于指定网络地址号，192.168.14.0代表的是网段，而不是IP。

**子网掩码**：也是一个ip地址，用来判断两台机器在不在一个局域网内。用其中一个ip地址和子网掩码进行按位与（先把每位都转成二进制，然后再按位与），在用另外一个ip地址和子网掩码进行按位与，然后比较两次按位与后的ip地址是否一样，如果一样，说明在同一个局域网，反之，不在同一个局域网。

比如192.168.12.1和192.168.13.1，前面只有2位一样（192.168），所以只需2个255，即子网掩码是255.255.0.0，能说明这两个ip在同一个局域网。

有两台机器，分别是192.168.12.1和192.168.13.1，如何判断这两台地址在同一个网段内
    子网掩码是255.255.255.0-->11111111.11111111.11111111.00000000
    192.168.12.1-->11000000.10101000.00000110.00000001
    按位与后是11000000.10101000.00000110.00000000-->192.168.12.0
    
    192.168.13.1-->11000000.10101000.00000111.00000001
    按位与后是11000000.10101000.00000111.00000000-->192.168.13.0
    
    按位与后的两个地址不同，说明不在一个局域网，反之，在同一个局域网。
    上面例子说明不在同一个局域网。

#### 1.2 mac地址 ####

在网卡上，唯一。

**arp协议**：地址解析协议。通过一台机器的ip地址获取到它的mac地址，用到了交换机的广播和单播功能。

**端口**

端口的范围：0 ~ 65535，用来确认机器上的具体应用程序的。

#### 2. 局域网 ####

##### 2.1 局域网内通信 #####

连在同一台**交换机**上的多台机器形成了局域网络，所有的消息传递，都是交给交换机来处理。交换机只识别mac地址。

我知道一台机器的ip地址，然后要给它发消息，由于交换机不认识ip地址，所以要先获取到这台机器的mac地址，然后双方都知道对方的mac地址，这样用交换机进行数据的传递就非常方便了。

交换机：广播、单播、组播

网段：192.168.12.XX

##### 2.2 局域网间通信 #####

需要借助**路由器**。路由器认识ip地址。路由器提供网关ip，同一个局域网的所有机器共享一个网关，我们不能访问除了本局域网之外的其他内网的ip地址。

网关：一个网络连接到另一个网络的“关口”。

## 二、最简单的网络通信-socket实现的代码 ##

### server.py ###

import socket
    # 套接字
    sk = socket.socket()  # 创建一个server端的对象
    sk.bind(('127.0.0.1', 9000))  # 给server端绑定一个地址
    sk.listen()  # 开始监听客户端给我的连接
    
    conn, adder = sk.accept()  # 建立连接，conn是连接
    
    # 服务端 发送 消息给客户端
    conn.send(b'hello')
    
    # 服务端 接收 来自客户端的消息
    msg = conn.recv(1024)
    print(msg)
    conn.close()  # 关闭连接
    
    sk.close()

### client.py ###

import socket
    
    sk = socket.socket()
    
    # 必须和server端的一致
    sk.connect(('127.0.0.1', 9000))
    msg = sk.recv(1024)
    print(msg)
    
    # 客户端 发送 消息给服务端
    sk.send(b'bye')
    
    sk.close()

## 三、tcp、udp、osi ##

七层协议：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

### 3.1 osi5层协议 ###

#### 3.1.1 理论 ####

应用层：python代码，b’hello’

传输层：预备如何传输、使用的**端口**，b’发送者的端口+hello+接受者的端口’

网络层：**ip**，b’发送者的ip+发送者的端口+hello+接受者的端口+接受者的端口’

数据链路层：**mac**，b’发送者mac地址+发送者的ip+发送者的端口+hello+接受者的端口+接受者的端口+接受者mac地址’

物理层：转化成电信号，通过网线传输

#### 3.1.2 每层涉及到的协议和物理设备 ####

第五层 应用层：python代码。

第四层 传输层：port，udp，tcp。四层路由器，四层交换机。

第三层 网络层：ipv4和ipv6。路由器，三层交换机。（家里的路由器带有交换机功能）

第二层 数据链路层：mac，arp协议。网卡，二层交换机。

第一层 物理层：网线。

### 3.2 tcp协议和udp协议 ###

#### 3.2.1 tcp协议 ####

tcp（语音聊天）- 线下缓存高清电影、qq远程控制、发邮件

需要先建立连接，然后才能通信的。

特点：占用连接、可靠（消息不会丢失）、实时性高、慢

建立连接：指三次握手

断开连接：指四次挥手

#### 3.2.2 udp协议 ####

udp（发短信）- 在线播放视频、qq发消息、微信发消息

不需要建立连接，就可以通信的。

特点：不占用连接、不可靠（消息可能因为网络不稳定而丢失）、快

## 四、tcp协议的代码 ##

**操作系统会统一分配计算机的所有资源**

socket()：tcp协议的server

socket(type=socket.SOCK\_DGRAM)：udp协议的server【udp协议中使用】

bind：绑定一个id和端口

listen：监听，代表socket服务的开启

accept：等到有客户端来访问，与客户端建立连接

send：直接通过连接发送消息，不需要写地址

sendto：需要写一个对方的地址【udp协议中使用】

recv：只接收消息

recvfrom：接收消息和地址【udp协议中使用】

connect：客户端/tcp协议的方法，和server端建立连接

close：关闭服务(sk.close)/连接(conn.close)

### 4.1 能够接收多个客户端的请求 ###

**server.py**

import socket
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9000))  # 申请操作系统的资源
    sk.listen()
    
    while True:
        # print(f'sk:{sk}')
        # conn里存储的是一个客户端和服务端的连接信息
        conn, adder = sk.accept()  # 能够和多个客户端进行握手了
        # print(f'conn:{conn}')
        conn.send(b'hello')
        msg = conn.recv(1024)
        print(msg)
        conn.close()  # 挥手，断开连接
    
    sk.close()  # 归还申请的操作系统的资源

**client.py**

### 4.2 在连接内，和客户端多说几句。以及解决不能传输中文问题 ###

**server.py**

import socket
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9000))  # 申请操作系统的资源
    sk.listen()
    
    while True:  # 为了和多个客户端进行握手
        # conn里存储的是一个客户端和服务端的连接信息
        conn, adder = sk.accept()  # 能够和多个客户端进行握手了
    
        while True:
            send_msg = input('please input you want say:')
    
            conn.send(send_msg.encode('utf-8'))
            if send_msg.upper() == 'Q':
                break
            msg = conn.recv(1024).decode('utf-8')
            if msg.upper() == 'Q':
                break
            print(msg)
        conn.close()  # 挥手，断开连接
    
    sk.close()

**client.py**

import socket
    
    sk = socket.socket()
    
    sk.connect(('127.0.0.1', 9000))
    
    while True:
        msg = sk.recv(1024).decode('utf-8')
        if msg.upper() == 'Q':
            break
        print(msg)
    
        send_msg = input('please input you want say:')
        sk.send(send_msg.encode('utf-8'))
        if send_msg.upper() == 'Q':
            break
    
    sk.close()

### 4.3 程序执行到哪里会阻塞，什么时候结束阻塞 ###

input() 等待，直到用户输入enter键
    
    accept() 阻塞，有客户端来与我建立完连接之后
    
    recv() 阻塞，直到收到对方发过来的消息之后
    
    recvfrom() 阻塞，直到收到对方发过来的消息之后
    
    connect() 阻塞，直到server端结束了对一个client的服务，开始和当前client建立连接的时候

## 五、udp协议的代码 ##

**server.py**

import socket
    
    sk = socket.socket(type=socket.SOCK_DGRAM)  # 表示一个udp协议
    sk.bind(('127.0.0.1', 9000))
    
    # 服务端不能先发送消息，因为服务端不知道客户端的ip
    while True:
        msg, addr = sk.recvfrom(1024)
        print(msg.decode('utf-8'))
        send_msg = input('please input you want say:')
        sk.sendto(send_msg.encode('utf-8'), addr)
    # server端不需要判断退出
    # 因为不和这个客户端通信，还要和其他客户端通信

**client.py**

import socket
    
    sk = socket.socket(type=socket.SOCK_DGRAM)
    server = ('127.0.0.1', 9000)
    
    while True:
        send_msg = input('please input you want say:')
        if send_msg.upper() == 'Q':
            break
        sk.sendto(send_msg.encode('utf-8'), server)
        msg = sk.recv(1024).decode('utf-8')
        if msg.upper() == 'Q':
            break
        print(msg)

## 六、粘包问题 ##

### 6.1 tcp协议中的粘包现象 ###

两条或更多条分开发送的信息连在一起就是粘包现象

#### server.py ####

import socket
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9001))
    sk.listen()
    
    conn, addr = sk.accept()
    conn.send(b'hello')
    conn.send(b'nice')
    conn.close()
    sk.close()

#### client.py ####

import time
    import socket
    
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9001))
    
    time.sleep(0.1)
    msg1 = sk.recv(1024)
    print(msg1)
    msg2 = sk.recv(1024)
    print(msg2)
    
    sk.close()

先启动server，然后启动client，client打印结果如下：

b'hellonice'
    b''

产生了粘包现象，去掉睡眠时间结果如下：

b'hellonice'
    b'nice'

【注意】即使不设置睡眠时间，也有几率粘包

### 6.2 产生粘包现象的两个原因 ###

**粘包现象只出现在tcp协议中**，因为tcp协议中，多条消息之间没有边界（流式传输），并且还有一大堆优化算法。

*  发送端：两条消息很短，并且发送的间隔时间也很短，由于优化机制就合并在一起发送了
 *  接收端：多条消息由于没有及时接收，在接收方的缓存中堆在一起而导致的粘包

### 6.3 粘包发生的本质 ###

tcp协议的传输是流式传输，数据与数据之间没有边界

### 6.4 解决粘包的问题的本质 ###

设置边界

### 6.5 解决粘包 ###

自定义协议

服务端：先发送4个字节的数据长度，再按照长度发送数据

客户端：先接收4个字节，知道数据的长度，再按照长度接收数据

### 6.6 struct模块 ###

该模块可以把一个类型，如数字，转成固定长度的 bytes。

数字的范围 `-2**31-1 ~ 2**31`，共 2\*\*32 个数字。pack可以把这个范围内的任意一个数字转为长度为 4 的字节。

import struct
    
    num1 = 123456789
    num2 = 12345
    num3 = 123
    
    ret1 = struct.pack('i', num1)
    print(ret1, len(ret1))  # b'\x15\xcd[\x07' 4
    ret2 = struct.pack('i', num2)
    print(ret2, len(ret2))  # b'90\x00\x00' 4
    ret3 = struct.pack('i', num3)
    print(ret3, len(ret3))  # b'{\x00\x00\x00' 4
    
    print(struct.unpack('i', ret1))  # (123456789,)
    print(struct.unpack('i', ret2))  # (12345,)
    print(struct.unpack('i', ret3))  # (123,)

### 6.7 解决粘包代码 ###

#### server.py ####

import socket
    import struct
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9001))
    sk.listen()
    
    conn, addr = sk.accept()
    msg1 = input('>>>')
    msg2 = input('>>>')
    blen = struct.pack('i', len(msg1.encode()))
    conn.send(blen)
    conn.send(msg1.encode())
    conn.send(msg2.encode())
    conn.close()
    sk.close()

#### client.py ####

import time
    import socket
    import struct
    
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9001))
    
    time.sleep(0.1)
    length = sk.recv(4)
    length = struct.unpack('i', length)[0]
    msg1 = sk.recv(length)
    msg2 = sk.recv(1024)
    
    print(msg1.decode('utf-8'))
    print(msg2.decode('utf-8'))
    
    sk.close()

### 6.8 总结 ###

1.  recv(1024)不代表一定收到1024个字节，而是最多只能收1024个字节
2.  两条连续发送的数据一定要避免粘包问题
3.  tcp协议的自定义协议解决粘包问题的思路：先发送数据的长度，再发送数据。【将发送的数据组成json格式：先发送json的长度，再发json（json中存了接下来要发送的数据长度），再发数据】

## 七、基于udp协议的多人聊天 ##

### 7.1 基于udp协议的多人聊天 ###

自动识别用户，不能使用 ip 和 port

#### server.py ####

import socket
    
    friend_lst = { 'jack': '31', 'tom': '34'}
    sk = socket.socket(type=socket.SOCK_DGRAM)
    sk.bind(('127.0.0.1', 9000))
    while 1:
        msg, addr = sk.recvfrom(1024)
        msg = msg.decode('utf-8')
        name, message = msg.split('|')
        print(f'\033[1;{friend_lst.get(name,"30")}m {name}：{message} \033[0m')
        content = input('>>>')
        sk.sendto(content.encode('utf-8'), addr)

#### client.py ####

import socket
    
    name = 'jack'
    sk = socket.socket(type=socket.SOCK_DGRAM)
    
    while 1:
        content = input('>>>')
        if content.upper() == 'Q':
            break
        content = f'{name}|{content}'
        sk.sendto(content.encode('utf-8'), ('127.0.0.1', 9000))
        msg = sk.recv(1024).decode('utf-8')
        if msg.upper() == 'Q':
            break
        print(msg)

## 八、基于tcp协议的文件传输 ##

### server.py ###

import socket
    import json
    # 接收
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9002))
    sk.listen()
    conn, addr = sk.accept()
    msg = conn.recv(1024).decode('utf-8')
    msg = json.loads(msg)
    
    with open(msg['filename'], 'wb') as f:
        content = conn.recv(msg['filesize'])
        print('-->', len(content))
        f.write(content)
    
    print(msg)
    conn.close()
    sk.close()

### client.py ###

import os
    import json
    import socket
    
    # 发送
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9002))
    
    # 文件名、文件大小
    abs_path = r'E:\A.PythonProject\action\day30\作业\a.txt'
    filename = os.path.basename(abs_path)
    filesize = os.path.getsize(abs_path)
    dic = { 'filename': filename, 'filesize': filesize}
    str_dic = json.dumps(dic)
    sk.send(str_dic.encode('utf-8'))
    
    with open(abs_path, 'rb') as f:
        content = f.read()
        sk.send(content)
    sk.close()

### 8.1 优化 ###

上面代码存在的问题：发送的字典可能和文件内容发送粘包；发送大文件时，接收的文件大小比原来的小

#### server.py ####

import socket
    import json
    # 接收
    import struct
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9002))
    sk.listen()
    conn, addr = sk.accept()
    msg_len = conn.recv(4)
    dic_len = struct.unpack('i', msg_len)[0]
    msg = conn.recv(dic_len).decode('utf-8')
    msg = json.loads(msg)
    
    with open(msg['filename'], 'wb') as f:
        while msg['filesize'] > 0:
            content = conn.recv(1024)
            # msg['filesize'] -= 1024 传过来的大小不一定是1024
            msg['filesize'] -= len(content)
            f.write(content)
    
    conn.close()
    sk.close()

#### client.py ####

import os
    import json
    import struct
    import socket
    
    # 发送
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9002))
    
    # 文件名、文件大小
    # 必须是一个绝对路径
    abs_path = r'E:\A.PythonProject\action\day30\作业\a.txt'
    filename = os.path.basename(abs_path)
    filesize = os.path.getsize(abs_path)
    dic = { 'filename': filename, 'filesize': filesize}
    str_dic = json.dumps(dic)
    b_dic = str_dic.encode('utf-8')
    mlen = struct.pack('i', len(b_dic))
    sk.send(mlen)  # 4个字节 表示字典转为字节之后的长度
    sk.send(b_dic)  # 具体的字典的数据
    
    with open(abs_path, 'rb') as f:
        while filesize > 0:
            content = f.read(1024)
            filesize -= 1024
            sk.send(content)
    sk.close()

## 九、验证客户端的合法性 ##

### server.py ###

import hashlib
    import os
    import socket
    secret_key = b'nice@123!'
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9001))
    sk.listen()
    
    conn, addr = sk.accept()
    # 创建一个随机的字符串
    rand = os.urandom(32)
    # 发送随机字符串
    conn.send(rand)
    # 根据发送的字符串 + secret_key 进行摘要
    sha = hashlib.sha1(secret_key)
    sha.update(rand)
    res = sha.hexdigest()
    # 等待接收客户端的摘要结果
    res_client = conn.recv(1024).decode('utf-8')
    # 做对比，如果一致，就显示是合法的客户端，并可以继续操作
    if res_client == res:
        print('是合法的客户端')
        conn.send(b'hello')
    else:
        # 如果不一致，应关闭连接
        conn.close()

### client.py ###

import hashlib
    import socket
    secret_key = b'nice@123!'
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9001))
    # 接收服务端发送的随机字符串
    rand = sk.recv(32)
    # 根据发送的字符串 + secret_key 进行摘要
    sha = hashlib.sha1(secret_key)
    sha.update(rand)
    res = sha.hexdigest()
    # 摘要结果发送回服务端
    sk.send(res.encode('utf-8'))
    # 继续和服务端进行通信
    msg = sk.recv(1024)
    print(msg)

### hmac模块 ###

用来替代 hashlib 模块

import os
    import hmac
    
    h = hmac.new(b'nice@123!', os.urandom(32))
    ret = h.digest()
    print(ret)

所以验证客户端合法性的代码可以简化。

## 十、socketserver模块 ##

socketserver 模块是基于 socket 模块完成的，socket 模块是底层模块，封装度低，效率不固定；socketserver 模块封装度高，效率比较固定。

### 10.1 作用 ###

tcp 协议的server端处理并发的客户端请求

#### server.py ####

import socketserver
    import time
    
    
    class Myserver(socketserver.BaseRequestHandler):
        # 重写handle
        def handle(self):
            # print(self.request)
            # <socket.socket fd=472, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9001), raddr=('127.0.0.1', 9040)>
            # 相当于conn，既有自己的ip，又有客户端的ip
            conn = self.request
            while 1:
                try:
                    content = conn.recv(1024).decode('utf-8')
                    conn.send(content.upper().encode('utf-8'))
                    time.sleep(0.5)
                except ConnectionResetError:
                    break
    
    
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 9001), Myserver)
    server.serve_forever()

#### client.py ####

import socket
    
    sk = socket.socket()
    sk.connect(('127.0.0.1', 9001))
    while 1:
        sk.send(b'hello')
        content = sk.recv(1024).decode('utf-8')
        print(content)

### 10.2 注意 ###

*  只改变了server端的代码，client端代码没有改变
 *  当客户端来连接的时候直接和handle中的代码交互