Python：打造你的HTTP应用帝国

---

一、引言

在当今互联网时代，HTTP 应用无处不在，从简单的网页浏览到复杂的 Web 服务交互，HTTP 协议作为应用层协议，是数据传输和交互的基石。Python 作为一种高级编程语言，以其简洁、高效、易读的特点，在 HTTP 应用开发领域占据着重要地位，成为众多开发者的首选。

Python 在 HTTP 应用开发中具有诸多优势。首先，Python 的语法简洁明了，代码可读性强，开发者能够用较少的代码实现复杂的功能，这大大提高了开发效率。例如，使用 Python 的requests库发送 HTTP 请求，只需几行代码即可完成，相比其他语言，代码量大幅减少，且逻辑清晰易懂。

其次，Python 拥有丰富的库和框架，这为 HTTP 应用开发提供了极大的便利。在 HTTP 客户端开发方面，requests库以其简单易用的 API，支持各种 HTTP 请求方法（GET、POST、PUT、DELETE 等），并内置了持久连接、会话管理、SSL 验证等功能，让开发者无需关注底层细节，专注于业务逻辑实现；aiohttp库则基于异步 I/O 模型，适用于处理高并发的 HTTP 请求，能够显著提升应用的性能和响应速度。在 HTTP 服务器端开发中，Flask 是一个轻量级 Web 框架，它提供了简单的路由系统和请求处理机制，适合快速搭建小型 Web 应用；Django 则是一个功能强大的全栈 Web 框架，具有丰富的插件和工具，如内置的数据库管理、用户认证、表单处理等功能，非常适合开发大型、复杂的 Web 应用。

此外，Python 还具有良好的跨平台性，可以在 Windows、Linux、macOS 等多种操作系统上运行，这使得基于 Python 开发的 HTTP 应用能够轻松部署到不同的环境中。同时，Python 拥有庞大且活跃的社区，开发者在遇到问题时，能够方便地从社区获取帮助、分享经验和学习资源，这进一步推动了 Python 在 HTTP 应用开发领域的广泛应用。

本文将通过具体实例，详细介绍如何使用 Python 进行 HTTP 应用开发，包括 HTTP 客户端和服务器端的开发，并提供完整的源代码，帮助读者快速掌握 Python 在 HTTP 应用开发中的技巧和方法，开启 HTTP 应用开发的奇妙之旅。

二、开发前准备

2.1 安装 Python

Python 的安装过程在不同操作系统下略有差异，下面将分别介绍在 Windows、macOS 和 Linux 系统中安装 Python 的步骤及版本选择建议。

• Windows 系统：
  • 下载安装包：访问 Python 官方网站（https://www.python.org/downloads/windows/ ），在下载页面根据你的 Windows 系统版本（64 位或 32 位）选择对应的 Python 安装包。建议下载最新的稳定版本，以获取最新的功能和性能优化。例如，当前最新稳定版本为 Python 3.12.6，就可以选择下载该版本的安装包。
  • 运行安装程序：下载完成后，双击安装包开始安装。在安装向导中，务必勾选 “Add Python to PATH” 选项，这将把 Python 添加到系统环境变量中，方便后续在命令行中直接使用 Python 命令。然后点击 “Install Now” 进行默认安装，也可以选择 “Customize installation” 进行自定义安装，如选择安装路径等。
  • 验证安装：安装完成后，打开命令提示符（CMD），输入 “python --version”，如果显示安装的 Python 版本号，如 “Python 3.12.6”，则说明安装成功。
• macOS 系统：
  • 下载安装包：前往 Python 官方网站（https://www.python.org/downloads/macos/ ），下载适用于 macOS 的 Python 安装包。同样建议选择最新稳定版本。
  • 安装：双击下载的.pkg 文件，按照安装向导的提示进行安装。安装过程中，系统可能会提示输入管理员密码。
  • 验证安装：打开终端（Terminal），输入 “python3 --version”，若显示正确的版本号，表明 Python 安装成功。这是因为 macOS 系统自带 Python 2.x 版本，为了区分，安装的 Python 3.x 版本通常通过 “python3” 命令来调用。另外，也可以使用 Homebrew 进行安装，在终端中执行 “brew install python” 命令即可，Homebrew 会自动安装最新版本的 Python，并管理其依赖项，这种方式更为便捷，且便于后续更新和管理 Python 版本。
• Linux 系统（以 Ubuntu 为例）：
  • 更新系统：在安装 Python 之前，先更新系统的软件包列表，在终端中执行 “sudo apt update” 命令。
  • 安装 Python：使用系统的包管理器进行安装，对于 Ubuntu 系统，执行 “sudo apt install python3” 命令，即可安装 Python 3。如果需要安装特定版本，如 Python 3.10，可以执行 “sudo apt install python3.10”。
  • 验证安装：安装完成后，在终端中输入 “python3 --version”，查看安装的 Python 版本。

在版本选择方面，强烈推荐使用 Python 3.x 版本，因为 Python 2.x 已于 2020 年停止维护，不再获得官方的更新和支持，存在安全风险。而 Python 3.x 在语法、功能和性能上都有显著提升，并且大多数新的库和框架都优先支持 Python 3.x。同时，还可以根据具体项目需求和第三方库的兼容性来确定具体的 Python 版本。例如，某些老旧项目可能依赖特定的 Python 3.6 或 Python 3.7 版本，此时就需要根据项目实际情况进行安装和配置。

2.2 选择开发工具

在 Python 开发中，选择一款合适的开发工具可以大大提高开发效率。以下为你推荐几款常见的开发工具，并说明它们的特点和优势。

• PyCharm：由 JetBrains 公司开发，是一款功能强大的 Python 集成开发环境（IDE），分为社区版（免费开源）和专业版（付费）。它具有以下特点和优势：
  • 智能代码编辑：提供智能代码补全、代码导航、代码重构等功能。比如在编写代码时，它能根据上下文准确地提示可能的代码选项，大大减少了代码输入量和错误率；代码导航功能可以让开发者快速定位到类、方法、变量的定义和引用处，方便代码的阅读和维护；代码重构功能支持在项目范围内轻松进行重命名、提取方法、导入域等操作，提高代码的可维护性和质量。
  • 强大的调试功能：内置功能全面的调试器，支持设置断点、单步调试、多画面视图、窗口以及评估表达式等。开发者可以方便地在调试过程中查看变量的值、程序的执行流程，快速定位和解决代码中的问题，缩短开发周期。
  • 丰富的插件生态系统：拥有大量的插件可供选择，如代码质量检查插件、数据库管理插件、Git 工具插件等，开发者可以根据自己的需求安装插件，进一步扩展 PyCharm 的功能，满足不同项目的开发需求。
  • 对 Python 框架的支持：对 Django、Flask 等常见 Python 框架有很好的支持，提供了专门的工具和模板，方便开发者快速搭建和开发 Web 应用，提高开发效率。例如，在创建 Django 项目时，PyCharm 可以自动生成项目的基本结构和配置文件，并且对 Django 的模板语法、数据库操作等都有智能提示和代码检查。
• Visual Studio Code（VS Code）：这是微软开发的一款轻量级、跨平台的源代码编辑器，通过安装扩展插件可以成为功能强大的 Python 开发工具。它的特点和优势如下：
  • 轻量级与高性能：启动速度快，占用系统资源少，即使在低配置的计算机上也能流畅运行，适合在各种环境下使用，无论是日常开发还是在配置有限的服务器上进行代码编辑。
  • 跨平台支持：支持 Windows、macOS 和 Linux 等多种操作系统，开发者可以在不同的平台上使用相同的开发工具，保持开发环境的一致性，方便项目的协作和部署。
  • 丰富的扩展库：拥有庞大的插件市场，开发者可以根据项目需求安装各种插件，如 Python 语言支持插件、代码格式化插件、调试插件、Git 版本控制插件等。这些插件极大地扩展了 VS Code 的功能，使其能够满足不同类型项目的开发需求。例如，安装 “Python” 插件后，VS Code 就具备了 Python 代码的语法高亮、智能补全、代码调试等功能；安装 “Auto Rename Tag” 插件可以自动重命名 HTML 和 XML 标签，提高前端开发效率。
  • 强大的代码编辑功能：提供代码自动补全、代码重构、代码高亮、智能缩进、代码片段等功能，能够帮助开发者快速编写高质量的代码。同时，VS Code 还支持分屏编辑和多光标操作，方便同时处理多个文件或在同一文件中进行多处修改，提高开发效率。
  • 内置终端和版本控制：内置集成终端，开发者可以在编辑器中直接执行命令，如运行 Python 脚本、安装依赖包等，无需切换到外部终端；并且对 Git 版本控制提供了良好的支持，在编辑器中可以方便地进行代码提交、拉取、推送、分支管理等操作，方便团队协作开发。

除了 PyCharm 和 VS Code，还有 Jupyter Notebook、IDLE 等开发工具。Jupyter Notebook 是一种基于 Web 的交互式计算环境，适合进行数据分析、机器学习模型开发和演示等工作，它可以将代码、文本、图像、公式等内容结合在一起，形成一个交互式的文档，便于分享和展示；IDLE 是 Python 自带的集成开发环境，简单易用，适合初学者学习 Python 基础知识和进行简单的代码编写。开发者可以根据自己的需求和偏好选择合适的开发工具。

三、使用 http.server 模块构建基本 HTTP 服务器

3.1 编写简单服务器代码

在 Python 中，http.server模块是标准库的一部分，无需额外安装即可使用，它提供了一个非常简便的方式来快速搭建一个基本的 HTTP 服务器，非常适合用于本地测试、文件共享或简单的 Web 服务开发。下面是使用http.server模块编写的一个简单 HTTP 服务器代码示例：

import http.server
import socketserver# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 设置响应状态码为200，表示成功self.send_response(200)# 设置响应头的Content-type为text/html，表示返回的内容是HTML格式self.send_header('Content-type', 'text/html')self.end_headers()# 要返回的HTML内容，这里是一个简单的包含标题和段落的HTML页面html_content = """<html><head><title>简单HTTP服务器</title></head><body><h1>欢迎访问我的简单HTTP服务器</h1><p>这是一个使用Python的http.server模块搭建的基本HTTP服务器示例。</p></body></html>"""# 将HTML内容编码为字节流并写入响应self.wfile.write(html_content.encode('utf-8'))# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

代码逻辑解释如下：

• 导入模块：首先导入http.server和socketserver模块，http.server模块用于构建 HTTP 服务器，socketserver模块是一个高层次的网络服务器框架，http.server基于它实现。
• 定义端口号：定义变量PORT并赋值为 8000，这是服务器监听的端口号。在实际应用中，可以根据需求修改此端口号，但要注意避免使用系统保留端口（如 0 - 1023），以免权限不足或端口冲突。
• 定义请求处理类：创建一个名为MyRequestHandler的类，它继承自http.server.SimpleHTTPRequestHandler。SimpleHTTPRequestHandler类提供了处理 HTTP 请求的基本功能，如处理 GET 和 HEAD 请求，默认情况下会返回当前目录下的文件。在这里，我们重写do_GET方法，以实现自定义的响应逻辑。
• 重写 do_GET 方法：在do_GET方法中，首先调用self.send_response(200)设置响应状态码为 200，表示请求成功处理。然后使用self.send_header(‘Content-type’, ‘text/html’)设置响应头的Content - type为text/html，告诉客户端返回的内容是 HTML 格式。接着调用self.end_headers()结束响应头的发送。之后定义要返回的 HTML 内容，存储在html_content变量中，这是一个简单的 HTML 页面，包含标题和段落。最后使用self.wfile.write(html_content.encode(‘utf-8’))将 HTML 内容编码为 UTF - 8 格式的字节流，并写入响应，发送给客户端。
• 创建并启动服务器：使用socketserver.TCPServer((“”, PORT), MyRequestHandler)创建一个 TCP 服务器，第一个参数(“”, PORT)是一个元组，空字符串表示服务器绑定到所有可用的网络接口，PORT是前面定义的端口号；第二个参数MyRequestHandler指定了处理请求的类。然后使用with语句来管理服务器的生命周期，在with代码块中，打印服务器运行信息，并调用httpd.serve_forever()启动服务器，使其持续运行，不断处理客户端发送过来的请求。

3.2 运行与测试

运行上述代码非常简单，打开终端（在 Windows 系统中可以使用命令提示符或 PowerShell，在 macOS 和 Linux 系统中使用终端），切换到保存上述代码的文件所在目录。假设代码文件名为simple_server.py，在终端中输入以下命令：

python simple_server.py

如果你的系统中同时安装了 Python 2 和 Python 3，建议使用python3命令来确保使用 Python 3 运行代码，即：

python3 simple_server.py

运行代码后，终端会输出 “服务器正在运行，监听端口 8000…” 的信息，表示服务器已经启动并开始监听 8000 端口。

接下来进行测试，打开浏览器，在地址栏中输入http://localhost:8000（如果修改了端口号，将 8000 替换为实际使用的端口号），然后按下回车键。浏览器会向服务器发送一个 HTTP GET 请求，服务器接收到请求后，会执行MyRequestHandler类中的do_GET方法，并返回自定义的 HTML 内容。此时，浏览器页面将显示如下内容：

简单 HTTP 服务器
这是一个使用 Python 的 http.server 模块搭建的基本 HTTP 服务器示例。

在测试过程中，如果遇到问题，比如无法访问服务器，可能是以下原因导致：

• 端口冲突：如果终端提示 “Address already in use” 错误信息，说明指定的端口号已经被其他程序占用。可以通过修改代码中的PORT变量，更换一个未被占用的端口号，然后重新运行服务器。
• 防火墙限制：防火墙可能会阻止浏览器与服务器之间的通信。可以暂时关闭防火墙，或者在防火墙上配置允许该端口的访问规则。在 Windows 系统中，可以在控制面板的防火墙设置中添加例外规则；在 Linux 系统中，可以使用iptables命令配置防火墙规则。
• 网络问题：确保服务器所在的计算机与访问的计算机处于同一网络，或者服务器所在计算机的网络配置正确，能够正常接收外部请求。

四、处理静态文件

4.1 修改服务器代码

在实际的 Web 应用中，除了返回动态生成的内容，还需要处理静态文件，如 HTML、CSS、JavaScript 文件等。下面我们对之前的服务器代码进行修改，使其能够处理静态文件。

import os
import http.server
import socketserver# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000
# 定义静态文件目录
STATIC_DIR ='static'# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 如果请求路径是根路径，设置为index.htmlif self.path == '/':self.path = '/index.html'try:# 拼接静态文件路径file_path = os.path.join(STATIC_DIR, self.path.lstrip('/'))# 以二进制模式打开文件with open(file_path, 'rb') as file:content = file.read()# 设置响应状态码为200，表示成功self.send_response(200)# 根据文件扩展名设置Content-typeif file_path.endswith('.html'):self.send_header('Content-type', 'text/html')elif file_path.endswith('.css'):self.send_header('Content-type', 'text/css')elif file_path.endswith('.js'):self.send_header('Content-type', 'application/javascript')else:self.send_header('Content-type', 'application/octet-stream')self.end_headers()# 将文件内容写入响应self.wfile.write(content)except FileNotFoundError:# 文件未找到，发送404错误响应self.send_error(404, 'File not found: %s' % self.path)# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

代码解释如下：

• 导入模块：除了之前的http.server和socketserver模块，还导入了os模块，用于处理文件和目录路径。
• 定义静态文件目录：定义变量STATIC_DIR并赋值为’static’，表示静态文件存放在项目目录下的static文件夹中。可以根据实际情况修改这个目录名。
• 修改 do_GET 方法：
  • 处理根路径请求：如果self.path为’/‘，表示请求的是根路径，将其设置为’/index.html’，这样当用户访问根路径时，服务器会返回index.html文件。
  • 拼接文件路径：使用os.path.join(STATIC_DIR, self.path.lstrip(‘/’))来拼接静态文件的完整路径。self.path.lstrip(‘/’)用于去除路径开头的斜杠，确保路径正确拼接。
  • 打开并读取文件：使用with open(file_path, ‘rb’)以二进制模式打开文件，并读取文件内容存储在content变量中。
  • 设置响应头：根据文件的扩展名设置Content - type响应头。如果是.html文件，设置为text/html；如果是.css文件，设置为text/css；如果是.js文件，设置为application/javascript；其他文件类型设置为application/octet - stream，表示二进制文件流。
  • 发送响应：设置响应状态码为 200，发送响应头，然后将文件内容写入响应，发送给客户端。
  • 处理文件未找到情况：如果在尝试打开文件时发生FileNotFoundError异常，说明文件不存在，调用self.send_error(404, ‘File not found: %s’ % self.path)发送 404 错误响应，告知客户端文件未找到。

4.2 创建与加载静态文件

在项目目录中创建一个名为static的文件夹（与代码中定义的STATIC_DIR一致），用于存放静态文件。在static文件夹中创建以下文件：

• index.html：

<!DOCTYPE html>
<html><head><title>静态文件示例</title><link rel="stylesheet" href="styles.css">
</head><body><h1>欢迎访问我的网站</h1><p>这是一个包含静态文件的示例页面。</p><script src="script.js"></script>
</body></html>

• styles.css：

body {font-family: Arial, sans-serif;background-color: #f0f0f0;
}h1 {color: blue;
}

• script.js：

console.log('这是一个JavaScript脚本文件');

启动服务器后，在浏览器中访问http://localhost:8000（如果修改了端口号，使用实际端口号），可以看到页面正确加载了index.html文件的内容，并且应用了styles.css中的样式，同时script.js脚本也在浏览器控制台中输出了相应的日志信息。这表明服务器成功处理了静态文件的请求 。如果在加载过程中出现问题，如样式未加载、脚本未执行等，可以检查文件路径是否正确、服务器代码是否有错误，以及浏览器的开发者工具中是否有相关的错误提示，以便及时排查和解决问题。

五、处理 POST 请求

5.1 支持 POST 请求的代码实现

在之前处理静态文件的服务器代码基础上，我们添加处理 POST 请求的功能。以下是完整代码：

import os
import http.server
import socketserver
import json# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000
# 定义静态文件目录
STATIC_DIR ='static'# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 如果请求路径是根路径，设置为index.htmlif self.path == '/':self.path = '/index.html'try:# 拼接静态文件路径file_path = os.path.join(STATIC_DIR, self.path.lstrip('/'))# 以二进制模式打开文件with open(file_path, 'rb') as file:content = file.read()# 设置响应状态码为200，表示成功self.send_response(200)# 根据文件扩展名设置Content-typeif file_path.endswith('.html'):self.send_header('Content-type', 'text/html')elif file_path.endswith('.css'):self.send_header('Content-type', 'text/css')elif file_path.endswith('.js'):self.send_header('Content-type', 'application/javascript')else:self.send_header('Content-type', 'application/octet-stream')self.end_headers()# 将文件内容写入响应self.wfile.write(content)except FileNotFoundError:# 文件未找到，发送404错误响应self.send_error(404, 'File not found: %s' % self.path)def do_POST(self):# 获取请求体的长度content_length = int(self.headers['Content-Length'])# 读取请求体数据post_data = self.rfile.read(content_length)try:# 尝试将请求体数据解析为JSON格式data = json.loads(post_data)self.send_response(200)self.send_header('Content-type', 'application/json')self.end_headers()response_data = {'status':'success', 'data': data}self.wfile.write(json.dumps(response_data).encode('utf-8'))except json.JSONDecodeError:# 如果解析失败，返回错误响应self.send_response(400)self.send_header('Content-type', 'application/json')self.end_headers()response_data = {'status': 'error','message': 'Invalid JSON data'}self.wfile.write(json.dumps(response_data).encode('utf-8'))# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

代码解释：

• 新增 do_POST 方法：在MyRequestHandler类中新增do_POST方法来处理 POST 请求。
  • 获取请求体长度：通过self.headers[‘Content-Length’]获取请求体的长度，它是 HTTP 头中的一个字段，表示请求体的字节数。
  • 读取请求体数据：使用self.rfile.read(content_length)从请求流中读取指定长度的字节数据，得到 POST 请求发送过来的数据。
  • 解析 JSON 数据：尝试使用json.loads(post_data)将读取到的字节数据解析为 JSON 格式的 Python 字典。如果解析成功，设置响应状态码为 200，响应头的Content - type为application/json，并构造包含成功状态和解析后数据的响应体，将其编码为 JSON 字符串发送给客户端。
  • 处理解析错误：如果在解析 JSON 数据时发生json.JSONDecodeError异常，说明接收到的数据不是有效的 JSON 格式，此时设置响应状态码为 400（表示客户端请求错误），并返回包含错误信息的 JSON 响应。

5.2 测试 POST 请求

我们可以使用 Postman 工具来测试服务器对 POST 请求的处理。打开 Postman，进行如下设置：

• 设置请求方法：选择 “POST”。
• 设置 URL：输入http://localhost:8000（如果修改了端口号，使用实际端口号）。
• 设置请求头：在 “Headers” 中添加 “Content-Type”，值为 “application/json”，表示发送的数据是 JSON 格式。
• 设置请求体：在 “Body” 中选择 “raw”，并确保右侧格式为 “JSON”，然后输入要发送的 JSON 数据，例如：

{"name": "John","age": 30
}

点击 “Send” 按钮发送请求，Postman 将显示服务器的响应。如果一切正常，将收到如下响应：

{"status": "success","data": {"name": "John","age": 30}
}

如果发送的数据不是有效的 JSON 格式，服务器将返回错误响应：

{"status": "error","message": "Invalid JSON data"
}

另外，也可以编写一个简单的 HTML 表单来发送 POST 请求。在static文件夹中创建一个post_form.html文件，内容如下：

<!DOCTYPE html>
<html><head><title>POST表单示例</title>
</head><body><h1>发送POST请求</h1><form action="http://localhost:8000" method="post"><label for="name">姓名:</label><br><input type="text" id="name" name="name"><br><br><label for="age">年龄:</label><br><input type="number" id="age" name="age"><br><br><input type="submit" value="提交"></form>
</body></html>

在浏览器中访问http://localhost:8000/post_form.html（如果修改了端口号，使用实际端口号），填写表单并提交。由于我们的服务器目前只处理 JSON 格式的 POST 数据，对于这种表单格式的数据，服务器将返回 400 错误响应，因为无法将表单数据解析为 JSON。若要处理表单数据，需要在do_POST方法中使用cgi.FieldStorage来解析表单数据 。这里只是展示如何通过 HTML 表单发送 POST 请求的方式，若要处理表单数据，代码需要相应调整。

六、使用 Flask 框架开发 HTTP 应用

6.1 Flask 简介与安装

Flask 是一个轻量级的 Python Web 框架，因其简洁、灵活和易于扩展的特性，在 Web 应用开发领域备受青睐。它被称为 “微框架”，这意味着它提供了 Web 开发的基本功能，如路由系统、请求处理和模板引擎，同时保持核心功能的简洁，让开发者可以根据项目需求自由选择和集成第三方扩展，以实现更复杂的功能。

Flask 的主要优势包括：

• 轻量级与简单易用：Flask 的设计理念是保持简洁，没有过多的内置功能和复杂的依赖关系，使得学习曲线较低，新手开发者可以快速上手，用较少的代码搭建出一个基本的 Web 应用。例如，创建一个简单的 Flask 应用只需几行代码，就能实现基本的路由和请求处理功能，相比一些功能全面但复杂的框架，大大降低了开发门槛。
• 高度灵活性：Flask 没有强制使用特定的数据库、模板引擎或其他工具，开发者可以根据项目的具体需求，自由选择适合的技术栈。比如，可以选择 SQLAlchemy 进行数据库操作，使用 Jinja2 作为模板引擎，也可以集成其他流行的数据库和模板引擎，这种灵活性使得 Flask 能够适应各种不同类型和规模的项目。
• 强大的路由系统：Flask 使用装饰器来定义路由，使得 URL 与处理函数之间的映射非常直观。通过简单的@app.route装饰器，就可以将一个 Python 函数映射到特定的 URL 路径上，当客户端访问该 URL 时，对应的函数就会被执行，这种方式极大地简化了 URL 的处理和管理，提高了开发效率。
• 丰富的扩展库：虽然 Flask 本身功能简洁，但它拥有庞大的扩展生态系统，通过各种扩展，如 Flask - SQLAlchemy（用于数据库操作）、Flask - Login（用于用户认证）、Flask - WTF（用于表单处理和验证）等，可以轻松为应用添加各种功能，满足不同项目的需求。

安装 Flask 非常简单，前提是已经安装了 Python 和 pip（Python 包管理器）。打开命令行界面（在 Windows 系统中可以使用命令提示符或 PowerShell，在 macOS 和 Linux 系统中使用终端），运行以下命令：

pip install flask

安装过程中，pip 会自动下载并安装 Flask 及其依赖项。安装完成后，可以通过运行以下命令来验证是否安装成功：

python -m flask --version

如果成功安装，将会输出 Flask 的版本信息。

6.2 构建 Flask 应用实例

下面是一个使用 Flask 构建的简单 HTTP 应用实例代码：

from flask import Flask# 创建Flask应用实例
app = Flask(__name__)# 定义路由和视图函数，处理根路径的GET请求
@app.route('/')
def hello_world():return 'Hello, World!'if __name__ == '__main__':# 启动Flask应用，监听在本地的5000端口，开启调试模式app.run(debug=True, port=5000)

代码结构和工作原理解释如下：

• 导入模块：首先从flask库中导入Flask类，Flask类是 Flask 框架的核心，通过创建它的实例来创建一个 Flask 应用。
• 创建应用实例：app = Flask(name)创建了一个 Flask 应用实例，__name__是 Python 的一个特殊变量，它表示当前模块的名称。在这个例子中，__name__的值通常是’main’，这告诉 Flask 应用的根目录，以便它可以找到模板文件、静态文件等资源。
• 定义路由和视图函数：使用@app.route装饰器定义路由，@app.route(‘/’)表示将根路径’/'映射到hello_world函数，这个函数被称为视图函数。当客户端发送一个 HTTP GET 请求到根路径时，Flask 会调用hello_world函数，该函数返回的字符串’Hello, World!'将作为 HTTP 响应的内容返回给客户端。
• 启动应用：在if name == ‘main’:代码块中，调用app.run()方法来启动 Flask 应用。debug=True表示开启调试模式，在调试模式下，Flask 会在代码发生变化时自动重新加载应用，并且在发生错误时提供详细的错误信息，方便调试；port=5000表示应用监听在本地的 5000 端口，客户端可以通过http://localhost:5000来访问这个应用。

运行上述代码，在终端中会输出类似以下信息：

 * Serving Flask app '__main__'* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.* Running on http://127.0.0.1:5000
Press CTRL+C to quit* Restarting with stat* Debugger is active!* Debugger PIN: 236-165-221

此时，打开浏览器，访问http://localhost:5000，浏览器页面将显示 “Hello, World!”，这表明 Flask 应用已经成功运行并处理了客户端的请求。

6.3 模板引擎使用

Flask 默认使用 Jinja2 作为模板引擎，Jinja2 允许在 HTML 文件中嵌入动态内容，通过模板变量、控制结构（如循环、条件判断）和宏等功能，使得 HTML 页面能够根据不同的数据和逻辑动态生成，从而提高页面的灵活性和可维护性，同时也实现了应用逻辑与页面呈现的分离。

下面是一个使用 Jinja2 模板引擎的示例，假设我们有一个简单的 Flask 应用，需要根据用户的名字显示个性化的问候页面：

from flask import Flask, render_templateapp = Flask(__name__)@app.route('/greet/<name>')
def greet(name):return render_template('greet.html', name=name)if __name__ == '__main__':app.run(debug=True, port=5000)

在上述代码中，render_template函数用于渲染模板文件。greet.html是模板文件名，name=name表示将视图函数中的name变量传递给模板。

接下来创建greet.html模板文件，保存在项目目录下的templates文件夹中（Flask 默认从templates文件夹中查找模板文件）：

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>问候页面</title>
</head><body><h1>Hello, {{ name }}!</h1><p>欢迎来到这个简单的Flask应用。</p>
</body></html>

在模板文件中，{{ name }}是一个模板变量，它会在模板渲染时被替换为从视图函数传递过来的实际值。当客户端访问http://localhost:5000/greet/John时，Flask 会调用greet视图函数，该函数使用render_template渲染greet.html模板，并将name变量的值’John’传递给模板，最终生成的 HTML 页面如下：

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>问候页面</title>
</head><body><h1>Hello, John!</h1><p>欢迎来到这个简单的Flask应用。</p>
</body></html>

这样，浏览器就会显示包含个性化问候的页面。除了简单的变量替换，Jinja2 还支持更复杂的逻辑，如循环和条件判断。例如，假设我们有一个用户列表，需要在模板中循环显示每个用户的信息：

from flask import Flask, render_templateapp = Flask(__name__)@app.route('/users')
def show_users():users = [{'name': 'Alice', 'age': 25},{'name': 'Bob', 'age': 30},{'name': 'Charlie', 'age': 35}]return render_template('users.html', users=users)if __name__ == '__main__':app.run(debug=True, port=5000)

在templates文件夹中创建users.html模板文件：

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>用户列表</title>
</head><body><h1>用户列表</h1><ul>{% for user in users %}<li>姓名: {{ user.name }}, 年龄: {{ user.age }}</li>{% endfor %}</ul>
</body></html>

在这个模板中，{% for user in users %}和{% endfor %}是 Jinja2 的循环控制结构，它会遍历users列表，并将每个用户的信息显示在 HTML 页面中。当客户端访问http://localhost:5000/users时，就可以看到一个包含所有用户信息的列表页面。

七、使用 Django 框架开发 HTTP 应用

7.1 Django 简介与安装

Django 是一个功能强大、基于 Python 的高级 Web 框架，它采用了 MTV（Model - Template - View）软件设计模式，为开发者提供了一站式的 Web 开发解决方案，能够显著提高开发效率，尤其适用于大型、复杂的 Web 应用程序开发。

Django 具有众多突出的特点和优势：

• 强大的内置功能：Django 内置了丰富的功能模块，涵盖数据库对象关系映射（ORM）、用户认证、表单处理、分页、站点地图生成等多个方面。例如，其 ORM 允许开发者使用 Python 代码与各种数据库（如 SQLite、MySQL、PostgreSQL 等）进行交互，而无需编写复杂的 SQL 语句；内置的用户认证系统提供了完善的用户注册、登录、密码重置等功能，大大减少了开发者在这些基础功能上的开发工作量。
• 安全保障：高度重视安全性，内置了多种安全机制，如防止 SQL 注入、跨站脚本攻击（XSS）、跨站请求伪造（CSRF）等。例如，在处理用户输入时，Django 会自动对数据进行转义，防止恶意代码注入；CSRF 保护机制会在表单提交等操作时验证请求的来源，确保请求是合法的，从而有效保护应用程序免受各种常见的安全威胁。
• 高效的开发模式：遵循 “不要重复自己”（DRY）的原则，鼓励代码的复用和模块化开发。通过其强大的命令行工具和自动化生成的代码结构，开发者可以快速搭建项目框架，专注于业务逻辑的实现。例如，使用django - admin startproject命令可以快速创建一个 Django 项目的基本结构，包括项目配置文件、URL 路由文件、WSGI 配置文件等；使用python manage.py startapp命令可以在项目中创建一个新的应用，每个应用都可以独立开发和维护，方便功能的拆分和团队协作。
• 优秀的文档和活跃的社区：拥有广泛的实践案例和完善的在线文档，这使得开发者在使用过程中能够快速找到解决方案，并且可以借鉴大量的优秀代码示例。此外，活跃的社区也为 Django 的不断发展和完善提供了有力支持，开发者可以及时获取最新的技术动态和更新补丁，在遇到问题时能够方便地从社区获取帮助。

安装 Django 前，确保已经安装了 Python 和 pip（Python 包管理器）。打开命令行界面（在 Windows 系统中可以使用命令提示符或 PowerShell，在 macOS 和 Linux 系统中使用终端），运行以下命令安装 Django：
pip install django

安装过程中，pip 会自动下载并安装 Django 及其依赖项。安装完成后，可以通过运行以下命令来验证是否安装成功：

python -m django --version

如果成功安装，将会输出 Django 的版本信息。

7.2 创建 Django 项目与应用

创建 Django 项目非常简单，打开命令行，切换到想要创建项目的目录，运行以下命令：

django-admin startproject myproject

这里的myproject是项目名称，可以根据实际情况进行修改。执行上述命令后，会在当前目录下创建一个名为myproject的项目文件夹，其目录结构如下：

myproject/
│
├── manage.py
└── myproject/├── __init__.py├── settings.py├── urls.py└── asgi.py└── wsgi.py

各文件和目录的作用如下：

• manage.py：一个命令行工具，用于管理 Django 项目，例如启动开发服务器、创建数据库迁移、创建超级用户等。通过它可以执行各种与项目相关的操作，是整个 Django 项目管理的核心入口。
• myproject/：项目的主目录，包含项目的配置文件和核心代码。
  • init.py：一个空文件，它的作用是将这个目录标记为一个 Python 包，这样 Python 就可以识别这个目录下的模块。
  • settings.py：项目的配置文件，包含了数据库配置、安装的应用程序列表、中间件设置、静态文件和媒体文件的配置等各种全局设置。例如，在这个文件中可以配置数据库的类型（如 SQLite、MySQL 等）、连接信息（主机、端口、用户名、密码等），以及设置项目的时区、语言等。
  • urls.py：项目的 URL 配置文件，定义了项目的 URL 路由规则，决定了不同的 URL 请求会被导向到哪个视图函数或者视图类进行处理。它就像是一个 URL 与视图函数之间的映射表，通过配置这个文件，可以实现不同 URL 路径与相应处理逻辑的关联。
  • asgi.py：在 Django 3.0 及更高版本中，此文件允许将项目配置为 ASGI 应用（Asynchronous Server Gateway Interface），即支持异步请求处理的应用程序接口，适用于生产环境中部署长连接或 WebSocket 服务。
  • wsgi.py：用于部署项目到 WSGI（Web Server Gateway Interface）兼容的 Web 服务器的入口点。当将项目部署到生产环境时，服务器会通过这个文件来启动 Django 应用。

接下来创建一个 Django 应用，在项目目录（即包含manage.py的目录）下运行以下命令：

python manage.py startapp myapp

这里的myapp是应用名称，可以自行修改。执行命令后，会在项目目录下创建一个名为myapp的应用文件夹，其结构如下：

myapp/
│
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
├── views.py
└── migrations/└── __init__.py

各文件的作用如下：

• init.py：将该目录标记为一个 Python 包。
• admin.py：用于注册模型，以便在 Django 的管理后台中对模型进行管理。例如，如果创建了一个用户模型，可以在这个文件中注册它，然后在管理后台中对用户数据进行增删改查操作。
• apps.py：应用程序的配置文件，在这里可以定义应用程序的一些配置信息，比如应用程序的名称、标签等。
• models.py：用于定义应用程序的数据模型。数据模型是 Django 中用于与数据库交互的核心部分，通过定义模型类，可以创建数据库表，并进行数据的存储、查询、更新和删除等操作。
• tests.py：用于编写测试用例，对应用程序的功能进行测试，以确保代码的正确性和稳定性。
• views.py：用于编写视图函数或视图类，处理用户的 HTTP 请求，并返回相应的响应。视图函数接收请求对象作为参数，根据请求的内容进行相应的处理，然后返回包含响应内容的 HTTP 响应对象。
• migrations/：数据库迁移目录，用于存储数据库迁移文件。数据库迁移是一种机制，用于在应用程序的数据模型发生变化时，自动更新数据库结构，确保数据库与模型的一致性。

7.3 配置路由与视图

在 Django 中，配置路由和编写视图函数是实现 HTTP 请求处理的关键步骤。首先，在项目的urls.py文件中配置路由，将 URL 映射到相应的视图函数。假设我们已经创建了一个名为myapp的应用，在myproject/urls.py文件中添加如下代码：

from django.contrib import admin
from django.urls import path, includeurlpatterns = [path('admin/', admin.site.urls),path('myapp/', include('myapp.urls')),
]

上述代码中，path(‘admin/’, admin.site.urls)用于配置 Django 自带的管理后台的 URL；path(‘myapp/’, include(‘myapp.urls’))表示将以myapp/开头的 URL 请求转发到myapp应用的urls.py文件中进行处理。

接下来，在myapp应用中创建urls.py文件（如果不存在），并编写如下代码：

from django.urls import path
from myapp import viewsurlpatterns = [path('hello/', views.hello_view, name='hello'),
]

这里定义了一个路由，当客户端访问myapp/hello/时，会调用myapp/views.py中的hello_view视图函数。

然后，在myapp/views.py中编写视图函数：

from django.http import HttpResponsedef hello_view(request):return HttpResponse('Hello, Django!')

hello_view函数接收一个request对象作为参数，它代表客户端发送的 HTTP 请求。函数返回一个HttpResponse对象，其内容为’Hello, Django!'，这个内容将作为 HTTP 响应返回给客户端。

启动 Django 开发服务器，在项目目录下运行以下命令：

python manage.py runserver

服务器启动后，打开浏览器，访问http://localhost:8000/myapp/hello/，页面将显示 “Hello, Django!”，表示路由和视图配置成功，Django 应用能够正确处理客户端的请求。

7.4 数据库操作（可选）

Django 提供了强大的数据库操作功能，通过其内置的 ORM（对象关系映射），可以使用 Python 代码方便地操作数据库，而无需编写原生的 SQL 语句。以下是一个简单的示例，展示如何在 Django 中使用模型类进行数据库的增删改查操作。

首先，在myapp/models.py中定义一个模型类，例如创建一个简单的Book模型：

from django.db import modelsclass Book(models.Model):title = models.CharField(max_length=200)author = models.CharField(max_length=100)publication_date = models.DateField()

上述代码定义了一个Book模型类，它继承自models.Model。Book模型包含三个字段：title（书名，字符类型，最大长度为 200）、author（作者，字符类型，最大长度为 100）和publication_date（出版日期，日期类型）。

定义好模型后，需要进行数据库迁移，让 Django 根据模型类创建相应的数据库表。在项目目录下运行以下命令：

python manage.py makemigrations
python manage.py migrate

makemigrations命令会根据模型类的变化生成迁移文件，记录模型的更改；migrate命令则会将这些迁移文件应用到数据库中，创建或更新数据库表结构。

接下来可以在视图函数中进行数据库的增删改查操作。例如，在myapp/views.py中添加以下代码：

from django.http import HttpResponse
from myapp.models import Bookdef create_book(request):new_book = Book.objects.create(title='Python Crash Course',author='Eric Matthes',publication_date='2015-05-01')return HttpResponse(f'成功创建书籍: {new_book.title}')def get_books(request):books = Book.objects.all()book_list = ', '.join([f'{book.title} by {book.author}' for book in books])return HttpResponse(f'所有书籍: {book_list}')def update_book(request):book = Book.objects.filter(title='Python Crash Course').first()if book:book.title = 'Python Crash Course 2nd Edition'book.save()return HttpResponse('书籍更新成功')else:return HttpResponse('未找到要更新的书籍')def delete_book(request):book = Book.objects.filter(title='Python Crash Course 2nd Edition').first()if book:book.delete()return HttpResponse('书籍删除成功')else:return HttpResponse('未找到要删除的书籍')

上述代码分别定义了创建书籍（create_book）、获取所有书籍（get_books）、更新书籍（update_book）和删除书籍（delete_book）的视图函数。在create_book函数中，使用Book.objects.create方法创建了一个新的书籍对象；get_books函数使用Book.objects.all方法获取所有的书籍对象，并将其格式化为字符串返回；update_book函数通过Book.objects.filter方法查找指定标题的书籍，然后修改其标题并保存；delete_book函数同样使用filter方法查找书籍，并调用delete方法删除 。

最后，在myapp/urls.py中添加相应的路由，将这些视图函数与 URL 进行映射：

from django.urls import path
from myapp import viewsurlpatterns = [path('create_book/', views.create_book, name='create_book'),path('get_books/', views.get_books, name='get_books'),path('update_book/', views.update_book, name='update_book'),path('delete_book/', views.delete_book, name='delete_book'),
]

这样，通过访问不同的 URL，就可以调用相应的视图函数，实现对数据库中书籍数据的增删改查操作。例如，访问http://localhost:8000/myapp/create_book/可以创建一本书籍，访问http://localhost:8000/myapp/get_books/可以获取所有书籍信息。

八、总结与拓展

通过本文的实例，我们全面了解了 Python 在 HTTP 应用开发中的多种方式和丰富应用场景。从使用标准库http.server模块快速搭建基本的 HTTP 服务器，实现简单的文件共享和静态文件处理，到深入学习 Flask 和 Django 等流行框架，构建功能强大、灵活可扩展的 Web 应用，Python 凭借其简洁的语法和丰富的库资源，为 HTTP 应用开发提供了高效且便捷的解决方案。

在开发 HTTP 客户端时，requests库以其简洁易用的 API，让我们能够轻松发送各种 HTTP 请求，处理响应数据，无论是获取网页内容、调用 Web API，还是与服务器进行数据交互，都能高效完成。而在服务器端开发中，http.server模块适合快速搭建简单的测试服务器；Flask 轻量级且灵活，适用于快速迭代开发小型 Web 应用，能够让开发者专注于核心业务逻辑；Django 则以其强大的内置功能和完善的生态系统，成为大型、复杂 Web 项目的首选框架，从数据库管理到用户认证，从表单处理到 URL 路由，Django 提供了一站式的解决方案，大大提高了开发效率和项目的可维护性。

然而，HTTP 应用开发的世界远不止于此。在实际项目中，还有许多方面值得深入探索和拓展。例如，为了提高应用的性能和并发处理能力，可以进一步学习异步编程，使用aiohttp库实现异步 HTTP 请求和响应处理，它基于 Python 的异步 I/O 机制，能够显著提升应用在高并发场景下的表现；在安全方面，要深入了解 HTTPS 协议，学会配置 SSL 证书，确保数据在传输过程中的加密和安全，防止数据泄露和中间人攻击；对于大型分布式系统，掌握 RESTful API 设计规范和微服务架构模式，能够构建更加灵活、可扩展的 Web 服务，实现不同服务之间的高效通信和协作。

同时，随着技术的不断发展，HTTP 协议也在持续演进，HTTP/2 和 HTTP/3 带来了性能上的大幅提升，如多路复用、头部压缩等特性，开发者应紧跟技术趋势，适时将这些新技术应用到项目中。此外，结合云计算平台，如 AWS、阿里云、腾讯云等，学会将 HTTP 应用部署到云端，利用云服务的弹性计算、负载均衡、自动扩展等功能，实现应用的高可用性和低成本运营。

希望读者通过本文的学习，能够掌握 Python 开发 HTTP 应用的基本技能，并在后续的学习和实践中不断探索，将这些知识应用到实际项目中，创造出更加优秀、高效的 HTTP 应用。

九、完整源码附录

使用 http.server 模块构建基本 HTTP 服务器

import http.server
import socketserver# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 设置响应状态码为200，表示成功self.send_response(200)# 设置响应头的Content-type为text/html，表示返回的内容是HTML格式self.send_header('Content-type', 'text/html')self.end_headers()# 要返回的HTML内容，这里是一个简单的包含标题和段落的HTML页面html_content = """<html><head><title>简单HTTP服务器</title></head><body><h1>欢迎访问我的简单HTTP服务器</h1><p>这是一个使用Python的http.server模块搭建的基本HTTP服务器示例。</p></body></html>"""# 将HTML内容编码为字节流并写入响应self.wfile.write(html_content.encode('utf-8'))# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

处理静态文件

import os
import http.server
import socketserver# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000
# 定义静态文件目录
STATIC_DIR ='static'# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 如果请求路径是根路径，设置为index.htmlif self.path == '/':self.path = '/index.html'try:# 拼接静态文件路径file_path = os.path.join(STATIC_DIR, self.path.lstrip('/'))# 以二进制模式打开文件with open(file_path, 'rb') as file:content = file.read()# 设置响应状态码为200，表示成功self.send_response(200)# 根据文件扩展名设置Content-typeif file_path.endswith('.html'):self.send_header('Content-type', 'text/html')elif file_path.endswith('.css'):self.send_header('Content-type', 'text/css')elif file_path.endswith('.js'):self.send_header('Content-type', 'application/javascript')else:self.send_header('Content-type', 'application/octet-stream')self.end_headers()# 将文件内容写入响应self.wfile.write(content)except FileNotFoundError:# 文件未找到，发送404错误响应self.send_error(404, 'File not found: %s' % self.path)# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

处理 POST 请求

import os
import http.server
import socketserver
import json# 定义端口号，这里使用8000，也可以根据需求修改
PORT = 8000
# 定义静态文件目录
STATIC_DIR ='static'# 定义请求处理类，继承自http.server.SimpleHTTPRequestHandler
class MyRequestHandler(http.server.SimpleHTTPRequestHandler):def do_GET(self):# 如果请求路径是根路径，设置为index.htmlif self.path == '/':self.path = '/index.html'try:# 拼接静态文件路径file_path = os.path.join(STATIC_DIR, self.path.lstrip('/'))# 以二进制模式打开文件with open(file_path, 'rb') as file:content = file.read()# 设置响应状态码为200，表示成功self.send_response(200)# 根据文件扩展名设置Content-typeif file_path.endswith('.html'):self.send_header('Content-type', 'text/html')elif file_path.endswith('.css'):self.send_header('Content-type', 'text/css')elif file_path.endswith('.js'):self.send_header('Content-type', 'application/javascript')else:self.send_header('Content-type', 'application/octet-stream')self.end_headers()# 将文件内容写入响应self.wfile.write(content)except FileNotFoundError:# 文件未找到，发送404错误响应self.send_error(404, 'File not found: %s' % self.path)def do_POST(self):# 获取请求体的长度content_length = int(self.headers['Content-Length'])# 读取请求体数据post_data = self.rfile.read(content_length)try:# 尝试将请求体数据解析为JSON格式data = json.loads(post_data)self.send_response(200)self.send_header('Content-type', 'application/json')self.end_headers()response_data = {'status':'success', 'data': data}self.wfile.write(json.dumps(response_data).encode('utf-8'))except json.JSONDecodeError:# 如果解析失败，返回错误响应self.send_response(400)self.send_header('Content-type', 'application/json')self.end_headers()response_data = {'status': 'error','message': 'Invalid JSON data'}self.wfile.write(json.dumps(response_data).encode('utf-8'))# 使用socketserver.TCPServer创建TCP服务器，绑定到指定地址（这里为空字符串，表示绑定到所有可用网络接口）和端口
with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:print(f"服务器正在运行，监听端口 {PORT}...")# 启动服务器，使其持续运行，处理客户端请求httpd.serve_forever()

使用 Flask 框架开发 HTTP 应用

from flask import Flask, render_templateapp = Flask(__name__)@app.route('/')
def hello_world():return 'Hello, World!'@app.route('/greet/<name>')
def greet(name):return render_template('greet.html', name=name)@app.route('/users')
def show_users():users = [{'name': 'Alice', 'age': 25},{'name': 'Bob', 'age': 30},{'name': 'Charlie', 'age': 35}]return render_template('users.html', users=users)if __name__ == '__main__':app.run(debug=True, port=5000)

使用 Django 框架开发 HTTP 应用

# myproject/urls.py
from django.contrib import admin
from django.urls import path, includeurlpatterns = [path('admin/', admin.site.urls),path('myapp/', include('myapp.urls')),
]# myapp/urls.py
from django.urls import path
from myapp import viewsurlpatterns = [path('hello/', views.hello_view, name='hello'),path('create_book/', views.create_book, name='create_book'),path('get_books/', views.get_books, name='get_books'),path('update_book/', views.update_book, name='update_book'),path('delete_book/', views.delete_book, name='delete_book'),
]# myapp/views.py
from django.http import HttpResponse
from myapp.models import Bookdef hello_view(request):return HttpResponse('Hello, Django!')def create_book(request):new_book = Book.objects.create(title='Python Crash Course',author='Eric Matthes',publication_date='2015-05-01')return HttpResponse(f'成功创建书籍: {new_book.title}')def get_books(request):books = Book.objects.all()book_list = ', '.join([f'{book.title} by {book.author}' for book in books])return HttpResponse(f'所有书籍: {book_list}')def update_book(request):book = Book.objects.filter(title='Python Crash Course').first()if book:book.title = 'Python Crash Course 2nd Edition'book.save()return HttpResponse('书籍更新成功')else:return HttpResponse('未找到要更新的书籍')def delete_book(request):book = Book.objects.filter(title='Python Crash Course 2nd Edition').first()if book:book.delete()return HttpResponse('书籍删除成功')else:return HttpResponse('未找到要删除的书籍')# myapp/models.py
from django.db import modelsclass Book(models.Model):title = models.CharField(max_length=200)author = models.CharField(max_length=100)publication_date = models.DateField()