Python网络编程

kiku18182026-04-11 13:23

从入门到实战：Python 网络编程 TCP/UDP 全解析，附聊天工具完整实现

摘要

本文系统梳理 Python 网络编程核心知识，从 TCP/UDP 协议底层原理、Socket 编程模型入手，详细拆解客户端 / 服务器端代码实现逻辑，补充粘包处理、超时设置、多线程并发等进阶知识点，并基于 TCP 协议从零实现可交互的简易聊天工具，覆盖从理论到实战的全流程。内容兼顾入门易懂性与工程实用性，适合运维、后端开发等方向学习者系统掌握 Python 网络编程核心技能，所有代码可直接运行，帮助读者快速落地网络通信应用开发。

一、前言：为什么要学 Python 网络编程？

随着互联网的普及，网络通信已经成为现代计算机应用的核心能力。无论是后端服务、运维监控工具，还是即时通讯、游戏开发，本质上都是网络编程的落地应用。而 Python 凭借其简洁的语法、丰富的标准库，成为了网络编程的首选语言之一 ------ 哪怕是零基础的开发者，也能快速写出可用的网络通信程序。

很多初学者刚接触网络编程时，会被 TCP、UDP、Socket 这些概念绕晕，分不清两者的区别，也不知道如何用 Python 实现客户端和服务器的通信。本文将从基础原理到实战代码，一步步拆解 Python 网络编程的核心知识，不仅覆盖文档中的基础内容，还补充大量工程中常用的进阶知识点，帮你彻底搞懂网络编程，并且能自己写出可用的聊天工具。

二、网络编程核心基础：TCP 与 UDP 协议

网络编程的本质，就是让两台计算机通过网络交换数据，而数据交换必须遵循统一的规则，这个规则就是网络协议。在传输层，最核心的两个协议就是 TCP 和 UDP，它们是所有网络通信的基础，也是 Python 网络编程的核心前提。

2.1 TCP 协议：面向连接的可靠传输

TCP（Transmission Control Protocol，传输控制协议）是面向连接 的协议，就像打电话：必须先拨号建立连接，才能通话，通话结束后还要挂断断开连接。它的核心特点就是可靠、有序、不丢包，具体特性如下：

  1. 面向连接 ：通信双方必须通过「三次握手」建立连接，数据传输完成后通过「四次挥手」断开连接，确保连接的可靠性。
    • 三次握手：客户端发送 SYN 请求→服务器回复 SYN+ACK 确认→客户端发送 ACK 确认，三次握手完成后连接建立，双方才能传输数据。
    • 四次挥手：主动关闭方发送 FIN 请求→被动方回复 ACK 确认→被动方发送 FIN 请求→主动方回复 ACK 确认，四次挥手完成后连接彻底断开。
  2. 可靠性保障 ：TCP 通过序列号、确认应答、超时重传、滑动窗口、拥塞控制五大机制，保证数据 100% 可靠传输。如果数据丢失、损坏，TCP 会自动重传，直到数据成功送达。
  3. 流量控制：通过滑动窗口技术，控制数据传输速率，避免发送方发送太快，接收方处理不过来导致数据丢失。
  4. 有序性：TCP 会给每个数据包编号，接收方按序号重组数据，保证接收顺序和发送顺序完全一致，不会出现乱序。
  5. 面向字节流：TCP 传输的是字节流，没有数据边界，这也是后续「粘包问题」的根源。

适用场景：对数据可靠性、顺序性要求极高的场景，比如文件传输、电子邮件、HTTP/HTTPS、数据库连接、远程登录等。

2.2 UDP 协议：无连接的高速传输

UDP（User Datagram Protocol，用户数据报协议）是无连接 的协议，就像寄快递：不需要提前建立连接，直接把数据发出去，不管对方有没有收到，也不管顺序对不对。它的核心特点是简单、快速、开销小，具体特性如下：

  1. 无连接：不需要建立连接，通信双方不需要三次握手，直接发送数据，延迟极低。
  2. 不可靠传输：不提供确认应答、重传机制，不保证数据顺序，可能会丢包、乱序、重复。
  3. 速度极快：因为不需要建立连接、处理复杂的可靠性机制，UDP 的传输速度远高于 TCP，延迟极低。
  4. 面向报文：UDP 传输的是独立的报文，有明确的数据边界，不会出现粘包问题。
  5. 支持广播 / 多播：可以同时向多个接收方发送数据，适合一对多的通信场景。

适用场景：对实时性要求高、能容忍少量丢包的场景，比如在线游戏、视频会议、直播、DNS 查询、物联网设备数据采集等。

2.3 TCP 与 UDP 核心区别对比

特性 TCP UDP
连接性 面向连接，需三次握手建立连接 无连接，无需建立连接
可靠性 可靠，保证数据不丢、有序 不可靠，可能丢包、乱序
传输速度 慢，开销大 快，开销小
数据边界 无，面向字节流，易粘包 有，面向报文，无粘包
适用场景 文件传输、HTTP、邮件等 游戏、直播、视频会议等
拥塞控制 支持 不支持
广播 / 多播 不支持 支持

三、网络编程的核心：Socket 编程模型

理解了 TCP 和 UDP 协议，接下来要学习的就是Socket（套接字）------ 它是网络通信的基础抽象层，是应用程序和网络协议之间的桥梁。简单来说，Socket 就是一个「通信端点」，客户端和服务器通过 Socket 来发送和接收数据，就像打电话需要电话一样，网络通信需要 Socket。

3.1 Socket 核心概念

在 Python 中，socket模块是标准库，直接内置，不需要额外安装，它封装了 TCP 和 UDP 协议的底层实现，我们只需要调用简单的 API，就能实现网络通信。

  • 地址族（Address Family） ：指定网络类型，最常用的是AF_INET（IPv4），还有AF_INET6（IPv6）、AF_UNIX（本地进程间通信）。
  • 套接字类型（Socket Type） ：指定协议类型，SOCK_STREAM对应 TCP 协议（流式套接字），SOCK_DGRAM对应 UDP 协议（数据报套接字）。
  • IP 地址 + 端口号：网络通信的唯一标识，IP 地址定位计算机，端口号定位计算机上的应用程序（端口号范围 0-65535，1024 以下是知名端口，比如 80 是 HTTP，22 是 SSH，开发时建议用 1024 以上的端口）。

3.2 Socket 通信的基本流程

TCP Socket 通信流程（面向连接）
  1. 服务器端：创建 Socket→绑定 IP 和端口→监听连接→接受客户端连接→收发数据→关闭连接
  2. 客户端：创建 Socket→连接服务器→收发数据→关闭连接
UDP Socket 通信流程（无连接）
  1. 服务器端：创建 Socket→绑定 IP 和端口→收发数据→关闭连接
  2. 客户端：创建 Socket→收发数据→关闭连接（不需要连接，直接发送）

四、TCP 编程：Python 实现 TCP 客户端与服务器

TCP 是面向连接的，所以客户端和服务器的通信必须先建立连接，再传输数据。下面我们用 Python 实现最基础的 TCP 客户端和服务器，并且详细拆解每一行代码的作用。

4.1 TCP 客户端示例：主动连接服务器，发送数据

python

运行

复制代码 
import socket

def tcp_client():
    # 1. 创建TCP客户端Socket
    # AF_INET：IPv4，SOCK_STREAM：TCP协议
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 2. 连接服务器（IP地址+端口号）
    # 127.0.0.1是本地回环地址，用于测试，实际使用时填服务器的真实IP
    server_address = ('127.0.0.1', 12345)
    client_socket.connect(server_address)
    
    try:
        # 3. 发送数据（必须编码为字节流，常用utf-8编码）
        message = 'Hello, Server! 我是TCP客户端'
        print(f"客户端发送：{message}")
        client_socket.send(message.encode('utf-8'))
        
        # 4. 接收服务器响应（最多接收1024字节，可根据需求调整）
        response = client_socket.recv(1024)
        print(f"客户端收到服务器响应：{response.decode('utf-8')}")
    finally:
        # 5. 关闭Socket连接，释放资源
        client_socket.close()

if __name__ == '__main__':
    tcp_client()

代码详细解释：

  • socket.socket(socket.AF_INET, socket.SOCK_STREAM)：创建 TCP 套接字，指定 IPv4 和 TCP 协议。
  • client_socket.connect(('127.0.0.1', 12345))：向服务器发起连接请求，触发三次握手，连接建立成功后才能发送数据。
  • client_socket.send()：发送数据，必须将字符串编码为字节流（encode('utf-8')），否则会报错。
  • client_socket.recv(1024)：接收数据，参数是最大接收字节数，返回的是字节流，需要用decode('utf-8')解码为字符串。
  • client_socket.close()：关闭连接，触发四次挥手，释放系统资源。

4.2 TCP 服务器示例：监听连接，处理客户端请求

python

运行

复制代码 
import socket

def tcp_server():
    # 1. 创建TCP服务器Socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 2. 绑定IP和端口（0.0.0.0表示监听所有网卡，允许外部设备连接）
    server_address = ('0.0.0.0', 12345)
    server_socket.bind(server_address)
    
    # 3. 开始监听连接，参数是最大等待连接数（backlog），一般设为5
    server_socket.listen(5)
    print(f"TCP服务器已启动，监听端口{server_address[1]}，等待客户端连接...")
    
    while True:
        # 4. 接受客户端连接（阻塞式，直到有客户端连接才会继续执行）
        # accept()返回两个值：客户端Socket对象、客户端地址（IP+端口）
        client_socket, client_address = server_socket.accept()
        print(f"收到客户端连接：{client_address}")
        
        try:
            # 5. 接收客户端数据
            message = client_socket.recv(1024)
            if message:
                print(f"服务器收到客户端消息：{message.decode('utf-8')}")
                
                # 6. 向客户端发送响应
                response = 'Hello, Client! 我是TCP服务器'
                client_socket.send(response.encode('utf-8'))
        finally:
            # 7. 关闭客户端Socket，本次通信结束
            client_socket.close()

if __name__ == '__main__':
    tcp_server()

代码详细解释：

  • server_socket.bind(('0.0.0.0', 12345))：绑定端口，0.0.0.0表示监听本机所有网卡的 IP，这样同一局域网的其他设备也能连接；如果填127.0.0.1，只能本机连接。
  • server_socket.listen(5)：开始监听，5是最大等待连接队列长度，超过这个数量的连接会被拒绝。
  • server_socket.accept()：阻塞方法，会一直等待客户端连接，连接成功后返回客户端 Socket 和地址，后续通过这个客户端 Socket 和客户端通信。
  • 服务器用while True循环，持续监听新的客户端连接，实现长驻服务。

4.3 TCP 编程进阶知识点（补充内容）

4.3.1 粘包问题：原因与解决方案

TCP 是面向字节流的，没有数据边界，如果客户端连续发送两次数据，服务器可能会一次性把两次数据一起接收，这就是粘包问题。

  • 产生原因：TCP 的 Nagle 算法会合并小数据包发送，加上接收缓冲区的存在，导致数据边界消失。
  • 解决方案 ：
    1. 固定长度：约定每次发送的数据长度固定，不足补空格，接收方按固定长度读取。
    2. 消息头 + 消息体：发送数据时，先发送 4 字节的消息长度，再发送消息内容；接收方先读 4 字节获取长度，再按长度读取消息，完美解决粘包。
    3. 特殊分隔符 ：用\n、\r\n等特殊字符作为消息分隔符，接收方按分隔符拆分数据（适合文本数据）。

消息头 + 消息体解决方案示例：

python

运行

复制代码 
# 发送端：先发送长度，再发送数据
import struct
message = "Hello, Server"
# 把长度打包为4字节的二进制数据（i表示int，4字节）
length = struct.pack('i', len(message))
client_socket.send(length)
client_socket.send(message.encode('utf-8'))

# 接收端：先读4字节长度，再读对应长度的数据
length_data = client_socket.recv(4)
length = struct.unpack('i', length_data)[0]
message = client_socket.recv(length).decode('utf-8')
4.3.2 超时设置：避免程序卡死

默认情况下，recv()、accept()都是阻塞式的，如果没有数据 / 连接，程序会一直卡死。可以通过settimeout()设置超时时间：

python

运行

复制代码 
# 设置超时时间为5秒，超过5秒没有数据，抛出socket.timeout异常
client_socket.settimeout(5.0)
try:
    response = client_socket.recv(1024)
except socket.timeout:
    print("接收数据超时")
4.3.3 地址复用：解决端口被占用问题

重启服务器时，经常会出现「端口被占用」的错误，这是因为 TCP 连接断开后，端口会处于 TIME_WAIT 状态，等待 2MSL（约 2 分钟）才能释放。可以通过setsockopt()开启地址复用：

python

运行

复制代码 
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(server_address)

五、UDP 编程：Python 实现 UDP 客户端与服务器

UDP 是无连接的，不需要建立连接，客户端直接向服务器发送数据，服务器直接接收，不需要三次握手，速度更快。下面实现基础的 UDP 客户端和服务器。

5.1 UDP 客户端示例：无连接发送数据

python

运行

复制代码 
import socket

def udp_client():
    # 1. 创建UDP客户端Socket（SOCK_DGRAM对应UDP）
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    # 2. 目标服务器地址
    server_address = ('127.0.0.1', 12345)
    
    try:
        # 3. 发送数据（不需要连接，直接sendto发送，指定目标地址）
        message = 'Hello, UDP Server! 我是UDP客户端'
        print(f"UDP客户端发送：{message}")
        client_socket.sendto(message.encode('utf-8'), server_address)
        
        # 4. 接收服务器响应（recvfrom返回数据和发送方地址）
        response, server_addr = client_socket.recvfrom(1024)
        print(f"UDP客户端收到服务器响应：{response.decode('utf-8')}，来自{server_addr}")
    finally:
        # 5. 关闭Socket
        client_socket.close()

if __name__ == '__main__':
    udp_client()

代码解释：

  • UDP 客户端不需要connect()，直接用sendto()发送数据，参数是数据和目标地址。
  • 用recvfrom()接收数据，返回两个值：数据字节流、发送方的地址（IP + 端口）。

5.2 UDP 服务器示例：无连接接收数据

python

运行

复制代码 
import socket

def udp_server():
    # 1. 创建UDP服务器Socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    # 2. 绑定IP和端口
    server_address = ('0.0.0.0', 12345)
    server_socket.bind(server_address)
    print(f"UDP服务器已启动，监听端口{server_address[1]}，等待数据...")
    
    while True:
        # 3. 接收客户端数据（recvfrom返回数据和客户端地址）
        data, client_address = server_socket.recvfrom(1024)
        print(f"UDP服务器收到来自{client_address}的消息：{data.decode('utf-8')}")
        
        # 4. 向客户端发送响应
        response = 'Hello, UDP Client! 我是UDP服务器'
        server_socket.sendto(response.encode('utf-8'), client_address)

if __name__ == '__main__':
    udp_server()

代码解释：

  • UDP 服务器不需要listen()和accept()，直接bind()端口后，用recvfrom()接收数据即可。
  • 因为 UDP 无连接，服务器可以同时接收多个客户端的数据，不需要为每个客户端创建新的 Socket。

5.3 UDP 编程进阶知识点（补充内容）

5.3.1 UDP 的广播 / 多播实现

UDP 支持广播，只需要把目标地址设为广播地址（比如255.255.255.255），就能向局域网内所有设备发送数据：

python

运行

复制代码 
# 开启广播权限
client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# 发送广播数据
client_socket.sendto(b"Broadcast message", ('255.255.255.255', 12345))
5.3.2 UDP 的可靠性补充

UDP 本身不可靠，如果需要在 UDP 上实现可靠传输，可以自己在应用层实现：比如给数据包加序号、确认应答、重传机制，类似 TCP 的逻辑，适合对实时性要求高、又需要一定可靠性的场景（比如游戏）。

六、实战：基于 TCP 的简易聊天工具（支持双向交互）

前面的示例都是单次通信，实际聊天工具需要支持客户端和服务器双向、持续发送消息，并且要解决「输入消息和接收消息阻塞冲突」的问题 ------ 这里我们用多线程实现，一个线程负责接收消息，一个线程负责发送消息，完美解决阻塞问题。

6.1 TCP 聊天客户端：支持双向收发

python

运行

复制代码 
import socket
import threading

def receive_message(client_socket):
    """子线程：持续接收服务器消息"""
    while True:
        try:
            # 接收服务器消息
            response = client_socket.recv(1024)
            if not response:
                print("服务器已断开连接")
                break
            print(f"\n服务器：{response.decode('utf-8')}")
            print("你：", end='', flush=True)  # 保持输入提示
        except Exception as e:
            print(f"接收消息出错：{e}")
            break

def tcp_chat_client():
    # 创建TCP Socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 连接服务器
    server_address = ('127.0.0.1', 12345)
    client_socket.connect(server_address)
    print("已连接到服务器，输入exit退出聊天")
    
    # 启动接收消息的子线程
    receive_thread = threading.Thread(target=receive_message, args=(client_socket,), daemon=True)
    receive_thread.start()
    
    # 主线程：负责发送消息
    while True:
        message = input("你：")
        if message.lower() == 'exit':
            client_socket.close()
            print("已退出聊天")
            break
        client_socket.send(message.encode('utf-8'))

if __name__ == '__main__':
    tcp_chat_client()

6.2 TCP 聊天服务器：支持多客户端连接（多线程版）

基础版服务器只能处理一个客户端，我们用多线程改造，支持同时连接多个客户端，实现群聊功能：

python

运行

复制代码 
import socket
import threading

# 保存所有连接的客户端Socket
clients = []
clients_lock = threading.Lock()  # 线程锁，保证线程安全

def handle_client(client_socket, client_address):
    """处理单个客户端的通信"""
    print(f"新客户端连接：{client_address}")
    # 加入客户端列表
    with clients_lock:
        clients.append(client_socket)
    
    try:
        while True:
            # 接收客户端消息
            message = client_socket.recv(1024)
            if not message:
                break
            print(f"客户端{client_address}：{message.decode('utf-8')}")
            
            # 群聊：把消息转发给所有其他客户端
            with clients_lock:
                for c in clients:
                    if c != client_socket:
                        try:
                            c.send(message)
                        except:
                            # 发送失败，移除客户端
                            clients.remove(c)
    except Exception as e:
        print(f"客户端{client_address}连接出错：{e}")
    finally:
        # 移除客户端，关闭连接
        with clients_lock:
            if client_socket in clients:
                clients.remove(client_socket)
        client_socket.close()
        print(f"客户端{client_address}已断开连接")

def tcp_chat_server():
    # 创建TCP服务器Socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 地址复用，解决端口占用
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 绑定端口
    server_socket.bind(('0.0.0.0', 12345))
    # 监听连接
    server_socket.listen(5)
    print("TCP群聊服务器已启动，等待客户端连接...")
    
    while True:
        # 接受客户端连接
        client_socket, client_address = server_socket.accept()
        # 为每个客户端创建独立线程处理
        client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address), daemon=True)
        client_thread.start()
        print(f"当前在线客户端数：{threading.active_count() - 1}")

if __name__ == '__main__':
    tcp_chat_server()

6.3 聊天工具使用说明

  1. 先运行tcp_chat_server.py，启动服务器，服务器会监听0.0.0.0:12345。
  2. 再运行多个tcp_chat_client.py，客户端会自动连接服务器，输入消息即可发送，服务器会把消息转发给所有其他客户端，实现群聊。
  3. 客户端输入exit即可退出聊天，服务器会自动移除断开的客户端。

七、总结与进阶学习方向

通过本文，我们系统学习了 Python 网络编程的核心知识：

  1. 底层原理：TCP/UDP 协议的区别、三次握手 / 四次挥手、Socket 编程模型。
  2. 基础实现：TCP/UDP 客户端 / 服务器的代码实现，每一行代码的详细解释。
  3. 进阶知识点：粘包问题、超时设置、地址复用、多线程并发、广播通信。
  4. 实战项目：基于 TCP 的多线程群聊工具，可直接运行使用。

7.1 TCP 与 UDP 选型建议

  • 选 TCP：当你需要100% 可靠传输，比如文件传输、支付系统、数据库连接、HTTP 服务。
  • 选 UDP：当你需要极致低延迟，能容忍少量丢包，比如游戏、直播、视频会议、物联网数据采集。

7.2 进阶学习方向

掌握基础后，可以继续深入学习以下内容，提升网络编程能力：

  1. IO 多路复用 ：用select、poll、epoll实现高并发服务器，替代多线程，提升性能（适合高并发场景）。
  2. 异步网络编程 ：用asyncio、aiohttp实现异步 TCP/UDP 服务器，性能远超同步多线程。
  3. 网络安全 ：学习 SSL/TLS 加密，给 Socket 通信加加密（ssl模块），防止数据被窃听。
  4. 网络框架：学习成熟的网络框架，比如 Twisted、Tornado，快速开发高性能网络应用。
  5. 网络协议深入：深入学习 HTTP/HTTPS、WebSocket 等应用层协议，基于 Socket 实现 HTTP 服务器。
相关推荐
新新学长搞科研2 小时前
【多所权威高校支持】第五届新能源系统与电力工程国际学术会议（NESP 2026）
运维·网络·人工智能·自动化·能源·信号处理·新能源
zncxCOS2 小时前
【ETestDEV5教程30】ICD操作之信号组操作
python·测试工具·测试用例·集成测试
小李子呢02112 小时前
前端八股3---ref和reactive
开发语言·前端·javascript
SWAGGY..2 小时前
【C++初阶】：（7）STL简介
开发语言·c++
智购科技自动售货机2 小时前
自动贩卖机厂家哪家价格公道
人工智能·python
dog2502 小时前
卡瓦列里积分赏析
开发语言·php
Thomas.Sir2 小时前
智能革命：AI如何重塑金融风控与信贷审批的底层逻辑
人工智能·python·ai·风控
流星蝴蝶没有剑2 小时前
CoPaw Agent 对接 Python 客户端开发指南：实现流式响应与实时打印
开发语言·python
咬_咬2 小时前
go语言学习（数组与切片）
开发语言·学习·golang·数组·切片
热门推荐
01GitHub 镜像站点02一周AI热点速览（2026.03.31-04.06）：GPT-6曝光、谷歌开源Gemma 4、资本狂飙与模型军备竞赛03OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程04AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南05VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）06实测！Gemma 4 成功跑在安卓手机上：离线 AI 助手终于来了07Oh My Codex 快速使用指南08CodeBuddy与WorkBuddy深度对比：腾讯两款AI工具差异及实操指南09MySQL表约束详解：8大核心约束实战指南10【STM32】HAL库 CubeMX 教程 --- 通用定时器 TIM2 定时