socket模块（套接字模块）

一、最简单版本（互传一次就结束）

# 客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8080))  # 8080是端口号
'''
来源百度百科
'127.0.0.1'是本机回还地址，不属于任何一个有类别地址类。它代表设备的本地虚拟接口，所以默认被看作是永远不会宕掉的接口。在Windows操作系统中也有相似的定义，所以通常在安装网卡前就可以ping通这个本地回环地址。一般都会用来检查本地网络协议、基本数据接口等是否正常的。
'''
client.send(b'hello, baby! I love you!')
msg = client.recv(1024)
print(msg.decode('utf-8'))


# 服务端
import socket
server = socket.socket()
server.bind(('127.0.0.1', 8080))  # 服务端绑定ip和端口号
server.listen(5)  # 半连接池，待连接（处于一个队列中）该服务端的客户端数不能超过5个
# 有一个房间，房间内是客户端和服务端，房间外有五张凳子，最多支持5个待连接客户端，再多就会报错
conn,addr = server.accept()
msg = conn.recv(1024)
print(msg.decode('utf-8'))
conn.send(b'I love you too!')

conn.close()  # 关闭连接
server.close()  # 关闭服务器

二、升级版（服务端不间断服务，客户端可以重复发送命令）

# 客户端
import json
import socket
import struct

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    cmd = input('>>>:').encode('utf-8')
    print(type(cmd))  # <class 'bytes'>
    if len(cmd) == 0:
        continue
    client.send(cmd)
    # 1.接收报头
    header_length = client.recv(4)
    print(type(header_length))  # <class 'bytes'>
    # 2.解包得到字典的长度
    d_length = struct.unpack('i', header_length)[0]
    print(type(d_length))  # <class 'int'>
    # 3.接收字典
    d = client.recv(d_length)
    print(type(d))  # <class 'bytes'>
    # 4.由字典拿到数据的长度
    real_d = json.loads(d)
    print(type(real_d))  # <class 'dict'>
    data_length = real_d['info_length']
    print(data_length)
    print(type(data_length))  # <class 'int'>
    # 5.接收真实数据
    with open('file', 'a', encoding='utf-8') as f:
        real_length = 0
        while real_length < data_length:
            data = client.recv(1024)
            real_length += len(data)
            f.write(data.decode('gbk'))


# 服务端
import json
import socket
import subprocess
import struct
from socket import SOL_SOCKET, SO_REUSEADDR

server = socket.socket()
# 避免因操作系统未及时回收端口造成的端口已被占用的问题
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 8080))
server.listen(5)

while True:
    conn, addr = server.accept()
    while True:
        try:
            cmd = conn.recv(1024).decode('utf-8')
            if len(cmd) == 0:
                break
            obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            print(type(obj))
            msg = obj.stdout.read() + obj.stderr.read()
            print(type(msg))  # <class 'bytes'>
            # 1.将数据长度放到字典中，将字典长度打包-报头
            d = {'info_length': len(msg)}
            json_d = json.dumps(d)
            print(type(json_d))  # <class 'str'>
            header = struct.pack('i', len(json_d))
            print(header)  # b'\x15\x00\x00\x00'
            # 2.发送报头
            conn.send(header)
            # 3.发送字典
            conn.send(json_d.encode('utf-8'))
            # 4.发送真实数据
            conn.send(msg)
        except ConnectionResetError:  # 
            break
    conn.close()

三、TCP传输的特点

• 应用程序所需要的数据，都是跟所在的那台计算机内存去要（所有数据传输都遵循这个规则）

• 会将数据量较小的并且时间间隔比较短的数据一次性打包发送给对方

# 客户端
import socket

client = socket.socket()  # 拿电话
client.connect(('127.0.0.1', 8080))  # 拨号   写的是对方的ip和port

client.send(b'hello')
client.send(b'world')
client.send(b'baby')
client.send(b'baby')


# 服务端
import socket

server = socket.socket()  # 买手机 不传参数默认用的就是TCP协议
server.bind(('127.0.0.1', 8080))  # bind((host,port))  插电话卡  绑定ip和端口
server.listen(5)  # 开机    半连接池

conn, addr = server.accept()  # 接听电话  等着别人给你打电话     阻塞
data = conn.recv(1024)  # 听别人说话 接收1024个字节数据          阻塞
print(data)
data = conn.recv(1024)  # 听别人说话 接收1024个字节数据          阻塞
print(data)
data = conn.recv(1024)  # 听别人说话 接收1024个字节数据          阻塞
print(data)

# 输出内容 理论上应该是在一行显示...
b'hello'
b'worldbabybaby'
b''

四、arp协议

• 先由IP地址找到对方，然后对方将自己的mac地址发回来

五、粘包问题

• 假设一种情况

  小明的妈妈给小明零花钱，给了他50块钱，放在了零钱罐中，但都是硬币，小明还小，两只手一次最多只能拿十个硬币，而且规定，小明只有在妈妈给他零花钱的时候才能从零钱罐中拿钱，所以，虽然妈妈每次都给小明50块的零花钱，但是小明实际上每次只能拿到10块钱。

• 假设另一种情况

  小明和小红在玩一个游戏，游戏规则如下：小红和小明面对面坐在桌子两侧，桌子上有三个罐子，小红小明各有一个，小红手上的罐子里有三个玻璃球，规定小红将自己罐子里的球倒入桌上的空罐子，倒三次；小明在小红将球放入罐子后，拿起罐子，将里面的球倒入自己的罐子中，也倒三次。游戏开始，小红往罐子里倒了球，小明拿起罐子，将球倒入自己的罐子中，发现一次性倒出三个球。他问小红，小红说她一次性讲球全部倒进去了

• 这两种情况分别是，一次拿少了，一次拿多了

六、解决粘包问题

• 解决粘包问题的关键在于，每一次拿的量是未知的
• 那么我们就要设法让服务端知道我们每一次传过去的数据的长度是多少

服务端
    1.先制作一个发送给客户端的字典
    2.制作字典的报头
    3.发送字典的报头
    4.发送字典
    5.再发真实数据
客户端
    1.先接受字典的报头
    2.解析拿到字典的数据长度
    3.接收字典
    4.从字典中获取真实数据的长度
    5.接收真实数据

socket模块（套接字模块）

原文：https://www.cnblogs.com/DcentMan/p/11380545.html