学习所有python写服务器的语句

"Python 写服务器"是一个非常宽泛的领域。由于 Python 拥有丰富的网络编程库和框架，要穷举所有可能的语句是不可能的。但我可以为你梳理从底层到高层，从同步到异步，从简单到复杂的各种服务器实现方式，并给出每个模式中最核心、最典型的代码片段。这些片段代表了构建服务器时最常用的语句和结构。

---

1. 基础 Socket 服务器（TCP / UDP）

TCP 服务器（单线程、阻塞式）

import socket

# 创建 socket 对象
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置重用地址（避免重启时 Address already in use）
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# 绑定地址和端口
server_socket.bind(('0.0.0.0', 8000))

# 开始监听，backlog 为最大等待连接数
server_socket.listen(5)

print("Server listening on port 8000...")

while True:
    # 接受客户端连接，返回新的 socket 和客户端地址
    client_socket, client_addr = server_socket.accept()
    print(f"Accepted connection from {client_addr}")

    # 接收数据（最多 1024 字节）
    data = client_socket.recv(1024)
    if data:
        # 发送响应
        client_socket.sendall(b"HTTP/1.1 200 OK\r\n\r\nHello, World!")
    
    # 关闭连接
    client_socket.close()

UDP 服务器（无连接）

import socket

udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server.bind(('0.0.0.0', 8000))

while True:
    data, client_addr = udp_server.recvfrom(1024)
    print(f"Received from {client_addr}: {data}")
    udp_server.sendto(b"ACK", client_addr)

多线程 TCP 服务器

import socket
import threading

def handle_client(client_socket, addr):
    with client_socket:
        data = client_socket.recv(1024)
        client_socket.sendall(b"Hello from thread")
    print(f"Handled {addr}")

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 8000))
server.listen()

while True:
    client, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(client, addr))
    thread.start()

---

2. 标准库 HTTP 服务器

简单的 HTTP 服务器（http.server）

import http.server
import socketserver

PORT = 8000

# 自定义请求处理器
class MyHandler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"Hello from custom handler")

with socketserver.TCPServer(("", PORT), MyHandler) as httpd:
    print(f"Serving at port {PORT}")
    httpd.serve_forever()

使用 socketserver 框架的 TCP 服务器

import socketserver

class MyTCPHandler(socketserver.StreamRequestHandler):
    def handle(self):
        data = self.rfile.readline().strip()
        self.wfile.write(b"Echo: " + data)

with socketserver.TCPServer(("localhost", 8000), MyTCPHandler) as server:
    server.serve_forever()

---

3. 使用 Web 框架（Flask / Django / Bottle）

Flask 微型 Web 服务器

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello, World!"

@app.route('/api/data', methods=['POST'])
def post_data():
    data = request.get_json()
    return jsonify({"received": data})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000, debug=True)

Django 开发服务器

# 在 Django 项目目录下
python manage.py runserver 0.0.0.0:8000

Bottle（单文件框架）

from bottle import route, run, request

@route('/')
def hello():
    return "Hello Bottle!"

@route('/echo', method='POST')
def echo():
    return request.body.read()

run(host='localhost', port=8000)

---

4. 异步服务器（asyncio）

原生 asyncio TCP 服务器

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    writer.write(f"Echo: {message}".encode())
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, '127.0.0.1', 8000)
    async with server:
        await server.serve_forever()

asyncio.run(main())

aiohttp（异步 HTTP 服务器）

from aiohttp import web

async def handle(request):
    name = request.query.get('name', 'Anonymous')
    return web.Response(text=f"Hello, {name}")

app = web.Application()
app.add_routes([web.get('/', handle)])

if __name__ == '__main__':
    web.run_app(app, host='0.0.0.0', port=8000)

FastAPI（高性能异步框架）

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# 运行：uvicorn main:app --host 0.0.0.0 --port 8000 --reload

---

5. WebSocket 服务器

使用 websockets 库

import asyncio
import websockets

async def echo(websocket, path):
    async for message in websocket:
        await websocket.send(f"Echo: {message}")

start_server = websockets.serve(echo, "localhost", 8000)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

使用 socket.io（通过 python-socketio）

import socketio

sio = socketio.Server(cors_allowed_origins='*')
app = socketio.WSGIApp(sio)

@sio.event
def connect(sid, environ):
    print('Client connected', sid)

@sio.event
def my_message(sid, data):
    sio.emit('response', {'data': data})

# 使用 eventlet 或 gevent 启动
if __name__ == '__main__':
    import eventlet
    eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

---

6. 其他协议服务器

SMTP 服务器（测试用）

import smtpd
import asyncore

class CustomSMTPServer(smtpd.SMTPServer):
    def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
        print(f"Message from {mailfrom} to {rcpttos}: {data[:50]}...")
        return

server = CustomSMTPServer(('0.0.0.0', 1025), None)
asyncore.loop()

FTP 服务器（pyftpdlib）

from pyftpdlib.authorizers import DummyAuthorizer
from pyftpdlib.handlers import FTPHandler
from pyftpdlib.servers import FTPServer

authorizer = DummyAuthorizer()
authorizer.add_user("user", "12345", ".", perm="elradfmw")

handler = FTPHandler
handler.authorizer = authorizer

server = FTPServer(("0.0.0.0", 21), handler)
server.serve_forever()

---

7. 高级模式：混合使用多线程/进程与异步

使用 gunicorn 部署 WSGI 应用

# 启动 4 个 worker 进程
gunicorn -w 4 -b 0.0.0.0:8000 myapp:app

使用 uvicorn 运行 ASGI 应用（如 FastAPI）

uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

---

总结：常见服务器语句分类

类别	典型语句 / 模块
底层网络	socket.socket(), .bind(), .listen(), .accept(), .recv(), .sendall()
多线程/多进程	threading.Thread(), multiprocessing.Process(), concurrent.futures
标准库 HTTP	http.server.SimpleHTTPRequestHandler, socketserver.TCPServer
Web 框架	Flask, Django, FastAPI, Bottle 的路由、运行函数
异步	asyncio.start_server(), await, async def, aiohttp.web, websockets.serve
部署	gunicorn, uvicorn, waitress, twisted 等启动命令
其他协议	smtpd.SMTPServer, pyftpdlib, telnetlib, xmlrpc.server

由于 Python 的生态极其丰富，上述内容无法涵盖所有可能的服务器语句，但应该能覆盖绝大多数开发场景的核心模式。如果你有特定的协议、框架或场景需求，欢迎进一步提问！