1. 网络编程基础

1.1 网络协议栈

网络通信遵循分层模型，每层负责不同的功能：

各层功能：

• 应用层：用户接口层（HTTP, FTP, SMTP等协议）
• 传输层：端到端通信（TCP/UDP协议）
• 网络层：数据包路由（IP协议）
• 链路层：物理介质传输（以太网、WiFi等）

要点：

• 数据从上层向下层封装传输
• 接收方从下层向上层解封装
• TCP提供可靠连接，UDP提供快速传输

1.2 Socket基础

Socket是网络编程的核心抽象，提供进程间通信接口。

Socket通信流程：

# 服务端
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建TCP socket
s.bind(('localhost', 12345))  # 绑定地址和端口
s.listen()  # 开始监听
conn, addr = s.accept()  # 接受客户端连接

# 客户端
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 12345))  # 连接到服务器

关键概念：

• AF_INET：IPv4地址族
• SOCK_STREAM：TCP协议
• SOCK_DGRAM：UDP协议
• bind()：绑定地址和端口
• listen()：开始监听连接
• accept()：接受客户端连接

注意事项：

• 端口号范围：0-65535（0-1023为系统保留端口）
• 客户端需要知道服务器的IP和端口
• 服务端需处理多个客户端连接（通常使用多线程/异步）

2. TCP/UDP编程

2.1 TCP编程

TCP提供可靠、面向连接的字节流传输。

TCP服务端实现：

def tcp_server():
    with socket.socket() as s:
        s.bind(('0.0.0.0', 8888))  # 监听所有网络接口
        s.listen()
        print("Server started")
        whileTrue:
            conn, addr = s.accept()
            with conn:
                print(f"Connected by {addr}")
                whileTrue:
                    data = conn.recv(1024)  # 接收数据
                    ifnot data:  # 客户端断开连接
                        break
                    conn.sendall(data.upper())  # 发送处理后的数据

TCP客户端实现：

def tcp_client():
    with socket.socket() as s:
        s.connect(('localhost', 8888))
        s.sendall(b"hello world")  # 发送数据
        data = s.recv(1024)  # 接收响应
        print(f"Received: {data.decode()}")

TCP特点：

• 三次握手建立连接
• 数据传输可靠、有序
• 拥塞控制和流量控制
• 适合文件传输、Web等需要可靠性的场景

2.2 UDP编程

UDP提供无连接、不可靠的数据报传输。

UDP服务端实现：

def udp_server():
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.bind(('0.0.0.0', 9999))
        while True:
            data, addr = s.recvfrom(1024)  # 接收数据和客户端地址
            print(f"From {addr}: {data.decode()}")
            s.sendto(data.upper(), addr)  # 发送响应到指定地址

UDP客户端实现：

def udp_client():
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.sendto(b"hello", ('localhost', 9999))  # 发送数据
        data, addr = s.recvfrom(1024)  # 接收响应
        print(f"From server: {data.decode()}")

UDP特点：

• 无连接，无需建立连接
• 不可靠但传输速度快
• 数据可能丢失或乱序
• 适合视频流、DNS查询等实时性要求高的场景

TCP vs UDP对比：

3. HTTP编程

3.1 使用http.client

Python标准库中的HTTP客户端实现：

from http.client import HTTPConnection

conn = HTTPConnection("example.com")  # 创建连接
conn.request("GET", "/")  # 发送GET请求
resp = conn.getresponse()  # 获取响应
print(resp.status, resp.reason)  # 状态码和原因短语
print(resp.read().decode()[:100])  # 读取响应内容

3.2 使用requests库（推荐）

第三方库，提供更简洁的API：

import requests

# GET请求示例
resp = requests.get("https://api.github.com/events")
print(resp.json()[0]['id'])  # 解析JSON响应

# POST请求示例
resp = requests.post("https://httpbin.org/post", 
                    data={'key': 'value'},  # 表单数据
                    headers={'X-Test': 'true'})  # 自定义请求头
print(resp.json())  # 输出JSON响应

HTTP编程技巧：

1. 使用Session对象保持会话（cookies持久化）
2. 设置超时参数避免程序阻塞
3. 处理HTTP状态码（200-成功，404-未找到等）
4. 使用try-except处理网络异常

4. WebSocket编程

WebSocket提供全双工通信通道，适合实时应用。

4.1 使用websockets库

import asyncio
import websockets

# 服务端实现
asyncdefecho(websocket):
    asyncfor message in websocket:
        await websocket.send(f"Echo: {message}")

asyncdefws_server():
    asyncwith websockets.serve(echo, "localhost", 8765):
        await asyncio.Future()  # 永久运行

# 客户端实现
asyncdefws_client():
    asyncwith websockets.connect("ws://localhost:8765") as ws:
        await ws.send("Hello WebSocket!")
        print(await ws.recv())  # 接收响应

# 启动服务端和客户端
asyncdefmain():
    server = asyncio.create_task(ws_server())
    await asyncio.sleep(1)  # 等待服务端启动
    await ws_client()
    server.cancel()

asyncio.run(main())

WebSocket特点：

• 单个TCP连接上全双工通信
• 低延迟，适合实时应用
• 服务端可以主动推送数据
• 广泛用于聊天应用、实时游戏、股票行情等场景

5. 异步网络编程

异步I/O允许单线程处理多个并发连接。

5.1 asyncio TCP示例

import asyncio

asyncdefhandle_echo(reader, writer):
    data = await reader.read(100)  # 异步读取数据
    message = data.decode()
    writer.write(data.upper())  # 发送响应
    await writer.drain()  # 等待写入完成
    writer.close()  # 关闭连接

asyncdefasync_tcp_server():
    server = await asyncio.start_server(
        handle_echo, '127.0.0.1', 8888)
    asyncwith server:
        await server.serve_forever()  # 永久运行

asyncdefasync_tcp_client():
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)
    writer.write(b"hello world")  # 发送数据
    data = await reader.read(100)  # 等待响应
    print(f"Received: {data.decode()}")
    writer.close()  # 关闭连接

asyncdefmain():
    server = asyncio.create_task(async_tcp_server())
    await asyncio.sleep(1)  # 等待服务器启动
    await async_tcp_client()
    server.cancel()  # 停止服务器

asyncio.run(main())

异步编程优势：

• 高并发处理能力
• 资源利用率高
• 适合I/O密集型应用
• 避免多线程的同步问题

关键概念：

• 事件循环（Event Loop）
• 协程（Coroutines）
• Future和Task对象
• async/await语法

6. 应用举例

6.1 简易HTTP服务器

from http.server import HTTPServer, BaseHTTPRequestHandler
import json

classAPIHandler(BaseHTTPRequestHandler):
    defdo_GET(self):
        ifself.path == '/api/data':
            self.send_response(200)  # 成功状态码
            self.send_header('Content-Type', 'application/json')
            self.end_headers()
            data = {'status': 'ok', 'data': [1,2,3]}
            self.wfile.write(json.dumps(data).encode())  # 发送JSON响应
        else:
            self.send_error(404)  # 资源未找到

defrun_server():
    server = HTTPServer(('localhost', 8000), APIHandler)
    print("Server started on http://localhost:8000")
    server.serve_forever()  # 启动服务器

6.2 网络监控工具

import socket
import time
from concurrent.futures import ThreadPoolExecutor

defcheck_port(host, port, timeout=1):
    """检查端口是否开放"""
    try:
        with socket.create_connection((host, port), timeout=timeout):
            returnTrue
    except (socket.timeout, ConnectionRefusedError):
        returnFalse

defnetwork_scanner(host, ports, max_workers=50):
    """多线程端口扫描器"""
    open_ports = []
    
    defworker(port):
        if check_port(host, port):
            open_ports.append(port)
            print(f"Port {port} is open")
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        executor.map(worker, ports)  # 并行执行端口检查
    
    returnsorted(open_ports)

# 使用示例
if __name__ == '__main__':
    host = 'example.com'
    ports = range(1, 1025)  # 扫描1-1024端口
    start = time.time()
    open_ports = network_scanner(host, ports)
    print(f"扫描完成，耗时 {time.time()-start:.2f}秒")
    print(f"{host} 开放端口: {open_ports}")

网络工具开发技巧：

1. 使用线程池提高扫描效率
2. 设置合理的超时时间
3. 遵守网络安全法规，仅扫描授权目标
4. 添加日志记录和错误处理

7. 知识图谱

学习路径建议：

1. 从Socket基础开始掌握网络通信原理
2. 理解TCP/UDP的核心差异和使用场景
3. 掌握HTTP客户端和服务端开发
4. 学习异步编程提高网络应用性能
5. 探索WebSocket实现实时应用
6. 实践网络工具和服务器开发

掌握Python网络编程是开发现代分布式应用的基础技能。通过本指南，我们已学习从底层Socket通信到高级异步网络应用的全面知识。继续实践这些概念，够构建高效、可靠的网络应用和服务。

阅读原文：原文链接