Python基础学习（5）网络编程socket套接字、文件上传、粘包问题、socketserver、IO多路复用、线程进程协程、进程池、线程池、上下文管理

最新推荐文章于 2024-07-04 04:29:08 发布

原创

最新推荐文章于 2024-07-04 04:29:08 发布 · 736 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Python

本文详细介绍了Python的网络编程基础，包括socket套接字的分类与使用，如AF_INET和AF_UNIX，以及如何创建简单的Server与Client。讨论了socket的多种操作，如bind、listen、accept、connect等。此外，还涉及文件上传、粘包问题的解决方案、socketserver、IO多路复用（如select和epoll）、线程与进程、协程的概念，以及线程池和进程池的使用。文章最后探讨了不同IO模型，如阻塞IO、非阻塞IO和多路复用IO，并强调了在Python中实现并发处理的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. socket套接字

socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。

1）套接字分类

（1）基于文件类型的套接字家族：AF_UNIX

（2）基于网络类型的套接字家族：AF_INET

简单的Server与Client案例：

import socket
# Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 9999, ))
server.listen(5)

# 接收客户端的请求

# 连接客户端地址信息
while True:
    conn, addr = server.accept()
    print(conn, addr)

import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))
client.close()

实现简单交互的socket案例版本一：

import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)

# 接收客户端的请求

# 连接客户端地址信息
while True:
    conn, addr = server.accept()
    conn.sendall(bytes("Hello World", encoding = "utf-8"))
    while True:
        rec_bytess = conn.recv(1024)
        rec_str = str(rec_bytess, encoding="utf-8")

        if rec_str == "exit":
            break

        conn.sendall(bytes(rec_str + "!", encoding="utf-8"))

    print(conn, addr)

import socket
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))

rec = client.recv(1024)
rec_str = str(rec, encoding="utf-8")
print(rec_str)

while True:
    inp = input("请输入要发送的内容：")

    if inp == "exit":
        client.sendall(bytes(inp, encoding="utf-8"))
        break
    else:
        client.sendall(bytes(inp, encoding="utf-8"))
        ret = str(client.recv(1024), encoding="utf-8")
        print(ret)



client.close()

版本二，可以对多个客户端提供服务，但没有实现多线程：

import socket
socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
socket.bind(('127.0.0.1', 8001))
socket.listen(5)

print('starting...')
while True: # 链接循环
    conn, client_addr = socket.accept()
    print(client_addr)
    
    while True: # 通信循环
        try:
            data = conn.recv(1024)
            if not data: break # 适用于linux系统
            print('客户端数据： ', data)
            conn.send(data.upper())
        except ConnectionResetError: # 适用于windows系统
            break
    conn.close()
socket.close()

import socket
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connet(('127.0.0.1', 8001))

while True:
    msg = input('>>: ').strip()
    if not msg: continue:
    socket.send(msg.encode('utf-8'))
    data = socket.recv(1024)
    print(data.decode('uff-8))

socket.close()

模拟ssh远程执行命令

Server:

import socket
import subprocess

socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1',8002))
socket.listen(5)

while True: 
    conn,client = socket.accept()
    
    while True:
        try:
            cmd = conn.recv(1024)
            if not cmd: break
      
            obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            conn.send(stdout + stderr)
        except ConnectionResetError:
            break
    conn.close()

socket.close()

Client:

import socket

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1', 8002))

while True:
    cmd = input('>>: ').strip()
    if not cmd: continue
    socket.send(cmd.encode('utf-8'))
    
    data = socket.recv(1024)
    print(data.decode('uff-8')

socket.close()

2.socket的更多功能

1）sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)

参数一：地址簇

socket.AF_INET IPV4（默认）

socket.AF_INET6 IPV6

socket.AF_UNIX 只能够用于单一的Unix系统进程间tongxin

参数二：类型

socket.SOCK_STREAM 流式socket, for TCP（默认）

socket.SOCK_DGRAM 数据报式socket，for UDP

socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，二SOCK_RAW可以，其次，SOCK_RAW也可以处理特殊的IPv4报文，此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

socket.SOCK_RDM是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。

socket.SOCK_SEQPACKET 可靠的连续数据包服务

参数三：协议

0 （默认）与特定的地址家族相关的协议，如果是0，则系统就会根据地址格式和套接类别，自动选择一个合适的协议

2）sk.bind(address)

sk.bind(address)将套接字绑定到地址。address地址的格式取决于地址簇。在AF_INET下，以元组(host,port)的形式表示地址。

3）sk.listen(backlog)

开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5

这个值不能无限大，因为要在内核中维护连接队列

4）sk.setblocking(bool)

是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

5）sk.accept()

接受连接并返回（conn, address），其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

接收TCP客户的连接（阻塞式）等待连接的到来

6）sk.connect(address)

连接到address处的套接字。一般address的格式为元组(hostname, port)，如果连接出错，返回socket.error错误。

7）sk.connect_ex(address)

同上，只不过会返回值，连接成功时返回0，连接失败时返回编码，例如：10061

8）sk.close()

关闭套接字

9）sk.recv(bufsize[,flag])

接收套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

10）sk.recvfrom(bufsize[.flag])

与recv()类似，但返回值是(data, address)。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

11）sk.send(string[,flag])

将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

12）sk.sendall(string[,flag])

将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常

内部通过递归调用send，将所有内容发送出去。

13）sk.sendto(string[,flag],address)

将数据发送到套接字，address是形式为(ipaddr, port)的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

14）sk.settimeout(timeout)

设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如client连接最多等待5s）

15）sk.getpeername()

返回连接套接字的远程地址。返回值通常是元组(ipaddr, port)

16）sk.getsockname()

返回套接字自己的地址。通常是一个元组(ipaddr, port)

17）sk.fileno()

套接字的文件描述符

18）socket.setsocketopt(socket.SOL_SOCKET, socket.REUSEADDR, 1)

重用ip和端口

3. 使用socket实现文件上传

import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)

# 接收客户端的请求

# 连接客户端地址信息
while True:
    conn, addr = server.accept()
    # 先接收文件大小
    file_size = str(conn.recv(1024), encoding="utf-8")
    total_size = int(file_size)
    has_recv = 0

    f = open("logo.png", "wb")
    # 然后再开始接收，直到获取完毕
    while True:
        if has_recv == total_size:
            break
        data = conn.recv(1024)
        f.write(data)
        has_recv += len(data)

    f.close()

import socket
import os
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))

# 发送当前文件大小
file_size = os.stat("fudan.png").st_size
client.sendall(bytes(str(file_size), encoding="utf-8"))

with open("fudan.png", "rb") as f:
    for line in f:
        client.sendall(line)

client.close()

4. 粘包问题

import socket
# Server
server = socket.socket()
server.bind(("127.0.0.1", 9999, ))
server.listen(5)

# 接收客户端的请求

# 连接客户端地址信息
while True:
    conn, addr = server.accept()
    # 先接收文件大小
    file_size = str(conn.recv(1024), encoding="utf-8")
    # 接收到文件大小之后，再向客户端发送一个确认信息，以解决粘包问题
    conn.sendall(bytes("Start to transfer the file", encoding="utf-8"))
    total_size = int(file_size)
    has_recv = 0

    f = open("logo.png", "wb")
    # 然后再开始接收，直到获取完毕
    while True:
        if has_recv == total_size:
            break
        data = conn.recv(1024)
        f.write(data)
        has_recv += len(data)

    f.close()

import socket
import os
# Client
client = socket.socket()
client.connect(("127.0.0.1", 9999, ))

# 发送当前文件大小
file_size = os.stat("1.png").st_size
client.sendall(bytes(str(file_size), encoding="utf-8"))
# 发送文件大小之后，等待服务器端的确认信息，以解决粘包问题
client.recv()

with open("1.png", "rb") as f:
    for line in f:
        client.sendall(line)

client.close()

制作报头，解决粘包问题

import socket
import subprocess
import struct
import json

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('127.0.0.1', 8002))
socket.listen(5)

while True:
    conn, client_addr = socket.accept()
    print(client_addr)

    while True:
        try:
            # 1. 接受命令
            cmd = conn.recv(1024)
            print(cmd)
            if not cmd:
                break

            # 2. 执行命令，获取结果
            obj = subprocess.Popen(cmd.decode('utf-8'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3. 把命令的结果返回给客户端
            # 第一步：制作固定长度的报头
            header_dict = {
                'filename': '1.txt',
                'md5': 'abc',
                'total_size': len(stdout) + len(stderr)
            }

            header_json = json.dumps(header_dict)