Python模块详解：从基础到高级应用

1. Python模块基础概念解析

Python模块是代码组织的基本单元，相当于一个包含Python定义和语句的文件。文件名就是模块名加上.py后缀。模块让你能够有逻辑地组织Python代码段，把相关的代码分配到一个模块里能让代码更好用，更易懂。

1.1 模块的创建与使用

创建模块非常简单，只需将代码保存为.py文件即可。例如，我们创建一个名为mymodule.py的文件：

# mymodule.py def greeting(name): print(f"Hello, {name}") person = { "name": "John", "age": 36, "country": "Norway" }

使用这个模块时，可以通过import语句导入：

import mymodule mymodule.greeting("Alice") print(mymodule.person["age"])

注意：模块名应该遵循Python变量命名规则，只能包含字母、数字和下划线，且不能以数字开头。

1.2 模块的搜索路径

当导入一个模块时，Python解释器会按照以下顺序搜索模块：

1. 当前目录
2. PYTHONPATH环境变量指定的目录列表
3. Python安装目录下的标准库目录
4. 任何.pth文件中的路径

可以通过sys.path查看当前的模块搜索路径：

import sys print(sys.path)

在实际项目中，我经常遇到模块导入失败的问题，90%的情况都是因为模块不在搜索路径中。解决方法通常有：

• 将模块所在目录添加到PYTHONPATH
• 使用相对导入（在包内部）
• 修改sys.path（临时解决方案）

2. Python标准库模块详解

Python标准库包含了大量实用的模块，这些模块随Python解释器一起安装，无需额外安装即可使用。

2.1 常用标准库模块

以下是一些最常用的标准库模块及其典型应用场景：

2.2 标准库模块使用示例

以datetime模块为例，展示如何使用标准库模块：

from datetime import datetime, timedelta # 获取当前时间 now = datetime.now() print(f"Current time: {now}") # 格式化输出 formatted = now.strftime("%Y-%m-%d %H:%M:%S") print(f"Formatted: {formatted}") # 时间计算 tomorrow = now + timedelta(days=1) print(f"Tomorrow: {tomorrow}") # 解析字符串 date_str = "2023-05-15" parsed_date = datetime.strptime(date_str, "%Y-%m-%d") print(f"Parsed date: {parsed_date}")

在实际开发中，我发现datetime模块的strftime和strptime方法经常被混淆。记忆技巧：strftime = "string from time"（时间转字符串），strptime = "string parse time"（字符串解析为时间）。

3. 第三方模块的管理与使用

Python生态系统的强大之处在于丰富的第三方模块。这些模块需要通过包管理工具安装后才能使用。

3.1 pip包管理工具

pip是Python的包管理工具，用于安装和管理第三方模块。常用命令包括：

# 安装最新版本 pip install package_name # 安装指定版本 pip install package_name==1.0.0 # 升级包 pip install --upgrade package_name # 卸载包 pip uninstall package_name # 列出已安装包 pip list # 生成requirements文件 pip freeze > requirements.txt # 从requirements文件安装 pip install -r requirements.txt

提示：建议在虚拟环境中使用pip，避免污染系统Python环境。可以使用venv或conda创建虚拟环境。

3.2 常用第三方模块推荐

根据多年使用经验，以下是一些高质量的第三方模块：

1. 数据分析与科学计算

   • numpy：高效的数值计算
   • pandas：数据处理与分析
   • matplotlib：数据可视化

2. Web开发

   • flask/django：Web框架
   • requests：HTTP请求
   • beautifulsoup4：HTML解析

3. 自动化与系统管理

   • psutil：系统监控
   • paramiko：SSH操作
   • pyautogui：GUI自动化

4. 数据库

   • sqlalchemy：ORM工具
   • pymysql：MySQL连接
   • redis-py：Redis客户端

5. 测试与调试

   • pytest：测试框架
   • ipdb：交互式调试器
   • coverage：代码覆盖率

4. 自定义模块与包的组织

当项目规模增大时，合理组织模块和包结构变得尤为重要。

4.1 包(Package)的创建

包是一种特殊的模块，它包含其他模块。创建包的步骤：

1. 创建一个目录作为包根目录
2. 在该目录下创建__init__.py文件（可以是空文件）
3. 添加模块文件或子包

示例目录结构：

mypackage/ ├── __init__.py ├── module1.py └── subpackage/ ├── __init__.py └── module2.py

4.2 相对导入与绝对导入

在包内部导入模块时，可以使用相对导入或绝对导入：

# 绝对导入（推荐） from mypackage.module1 import some_function # 相对导入（只能在包内部使用） from .module1 import some_function from ..otherpackage.module import other_function

在实际项目中，我建议遵循以下原则：

1. 优先使用绝对导入，除非有特殊需求
2. 避免循环导入
3. 在__init__.py中谨慎导入，避免不必要的开销

4.3 模块设计最佳实践

根据多年项目经验，总结出以下模块设计原则：

1. 单一职责原则：一个模块只做一件事，并做好
2. 合理的粒度：模块不宜过大也不宜过小，通常200-500行代码比较合适
3. 清晰的接口：通过__all__变量明确导出哪些内容
4. 充分的文档：模块级docstring和函数docstring
5. 单元测试：为每个模块编写测试用例

示例模块结构：

""" mymodule.py - 模块功能描述 这个模块实现了XXX功能，主要包含以下类和方法： - ClassA: 用于... - function1(): 实现... """ __all__ = ['ClassA', 'function1'] # 明确导出内容 class ClassA: """类功能说明""" def __init__(self): pass def function1(param1, param2): """函数功能说明 Args: param1: 参数1说明 param2: 参数2说明 Returns: 返回值说明 """ pass if __name__ == '__main__': # 模块测试代码 pass

5. 模块高级特性与技巧

5.1 动态导入模块

Python支持在运行时动态导入模块，这在插件系统等场景中非常有用：

module_name = "os" # 可以是变量 module = __import__(module_name) print(module.path) # 更现代的写法 import importlib module = importlib.import_module(module_name)

5.2 重新加载模块

在交互式环境或开发过程中，可能需要重新加载已导入的模块：

import importlib import mymodule # 修改mymodule.py后... importlib.reload(mymodule)

注意：reload不会影响已经创建的实例或导入的变量，使用时需谨慎。

5.3 模块缓存与.pyc文件

Python会将模块编译为.pyc文件缓存起来以提高导入速度。这些文件通常保存在__pycache__目录中。了解这一点有助于解决一些导入问题：

1. 删除.pyc文件可以强制Python重新编译模块
2. 在版本控制中通常忽略.pyc文件
3. 可以通过python -B命令禁用.pyc文件生成

5.4 模块属性与元信息

每个模块都有一些特殊属性，可用于获取模块信息：

import math print(math.__name__) # 模块名 print(math.__file__) # 模块文件路径 print(math.__doc__) # 模块文档字符串 print(math.__package__) # 所属包名 print(dir(math)) # 模块所有属性

6. 常见问题与解决方案

6.1 模块导入错误排查

1. ImportError: No module named 'xxx'

   • 检查模块是否安装（第三方模块）
   • 检查模块是否在搜索路径中（sys.path）
   • 检查拼写是否正确

2. AttributeError: module 'xxx' has no attribute 'yyy'

   • 检查模块是否包含该属性
   • 检查是否使用了from...import正确导入
   • 可能是模块版本问题

3. 循环导入问题

   • 重构代码结构，消除循环依赖
   • 将导入语句移到函数内部
   • 使用import ... as语法

6.2 模块性能优化技巧

1. 延迟导入：将导入语句放在函数内部，减少启动时间
2. 选择性导入：使用from...import只导入需要的部分
3. 缓存导入结果：对于频繁使用的模块，可以缓存其属性
4. 避免重复导入：Python会缓存已导入模块，无需担心重复导入开销

6.3 模块版本兼容性处理

处理不同版本模块的兼容性问题：

try: # 尝试导入新版本 from module import feature except ImportError: # 回退到旧版本 from old_module import old_feature as feature

或者使用标准库importlib.metadata检查已安装版本：

from importlib.metadata import version try: module_version = version("module_name") if module_version < "1.2.0": print("Warning: module version is too old") except ImportError: print("Module not installed")

7. 模块测试与文档

7.1 模块单元测试

为模块编写测试是保证质量的重要手段。使用unittest或pytest框架：

# test_mymodule.py import unittest from mymodule import function1 class TestMyModule(unittest.TestCase): def test_function1(self): result = function1(2, 3) self.assertEqual(result, 5) if __name__ == '__main__': unittest.main()

7.2 模块文档编写

良好的文档对模块的可维护性至关重要。Python支持多种文档格式：

1. Docstring：模块、类、函数的文档字符串
2. README：项目级文档
3. Sphinx：生成专业文档网站

示例模块文档字符串：

""" mymodule - 简短描述 详细描述模块功能、使用方法和示例。 Example: >>> import mymodule >>> mymodule.function1(2, 3) 5 Classes: ClassA: 类A的描述 Functions: function1(param1, param2): 函数1的描述 """ def function1(param1, param2): """执行计算并返回结果 Args: param1 (int): 第一个参数 param2 (int): 第二个参数 Returns: int: 计算结果 Raises: ValueError: 如果参数无效 """ if not isinstance(param1, int): raise ValueError("param1 must be integer") return param1 + param2

8. 模块发布与分发

8.1 打包模块

使用setuptools打包模块，创建setup.py文件：

from setuptools import setup, find_packages setup( name="mymodule", version="0.1", packages=find_packages(), description="My awesome module", author="Your Name", author_email="your@email.com", install_requires=[ 'requests>=2.25.0', 'numpy', ], python_requires='>=3.6', )

8.2 发布到PyPI

发布模块到Python Package Index (PyPI)的步骤：

1. 创建PyPI账号
2. 安装twine工具：pip install twine
3. 构建包：python setup.py sdist bdist_wheel
4. 上传包：twine upload dist/*

8.3 版本控制策略

遵循语义化版本控制(SemVer)：

• MAJOR.MINOR.PATCH
• MAJOR：不兼容的API修改
• MINOR：向下兼容的功能新增
• PATCH：向下兼容的问题修正

在模块中定义版本号：

# mymodule/__init__.py __version__ = "1.0.0"

9. 模块安全最佳实践

9.1 安全导入

避免直接执行不可信模块：

# 不安全的做法 module = __import__(user_input) # 更安全的做法 allowed_modules = {'os', 'sys'} if module_name in allowed_modules: module = __import__(module_name)

9.2 依赖安全

定期检查依赖的安全性：

1. 使用pip-audit检查已知漏洞
2. 定期更新依赖版本
3. 使用requirements.txt固定版本

9.3 代码审查

对模块代码进行安全审查，特别注意：

1. 危险函数调用（eval, exec, pickle等）
2. 文件系统操作
3. 网络请求
4. 子进程执行

10. 模块性能分析与优化

10.1 性能分析工具

Python提供了多种性能分析工具：

1. timeit：测量小段代码执行时间
2. cProfile：函数级性能分析
3. memory_profiler：内存使用分析
4. line_profiler：逐行性能分析

10.2 优化技巧

1. 减少全局变量访问：局部变量访问更快
2. 使用内置函数：比纯Python实现更快
3. 避免不必要的导入：特别是大型模块
4. 延迟导入：只在需要时导入
5. 使用__slots__：减少内存使用

10.3 编译扩展模块

对于性能关键模块，可以考虑：

1. Cython：将Python编译为C扩展
2. C扩展：直接用C编写Python扩展
3. Numba：JIT编译数值计算代码

示例使用Cython加速：

# mymodule.pyx def compute(int n): cdef int i, result = 0 for i in range(n): result += i return result

11. 模块在大型项目中的应用

11.1 项目结构组织

典型的大型Python项目结构：

project/ ├── docs/ # 文档 ├── tests/ # 测试 ├── src/ # 源代码 │ ├── package1/ # 包1 │ │ ├── __init__.py │ │ ├── module1.py │ │ └── subpackage/ │ └── package2/ # 包2 ├── scripts/ # 脚本 ├── setup.py # 打包配置 ├── requirements.txt # 依赖列表 └── README.md # 项目说明

11.2 模块化设计模式

1. 工厂模式：通过模块提供对象创建接口
2. 单例模式：模块天然的单例特性
3. 策略模式：通过模块实现不同算法
4. 观察者模式：模块间的事件通知

11.3 跨模块通信

1. 事件驱动：使用观察者模式
2. 消息队列：使用Redis/RabbitMQ
3. 共享状态：谨慎使用全局变量
4. 数据库：通过数据库共享数据

12. 模块的未来发展趋势

12.1 类型注解支持

Python类型注解对模块开发的影响：

from typing import List, Dict def process_data(data: List[Dict[str, int]]) -> Dict[str, float]: """处理数据并返回统计结果""" pass

12.2 异步模块

asyncio对模块设计的影响：

import asyncio async def fetch_data(url: str) -> str: """异步获取数据""" pass

12.3 模块化微服务

将模块作为微服务部署的趋势：

1. gRPC：高性能RPC框架
2. FastAPI：构建API服务
3. Celery：分布式任务队列

13. 模块调试技巧

13.1 调试导入问题

当模块导入出现问题时，可以：

1. 打印sys.path查看搜索路径
2. 检查__file__属性确认实际导入的文件
3. 使用python -v查看详细导入过程

13.2 交互式调试

使用pdb进行交互式调试：

import pdb def buggy_function(): pdb.set_trace() # 设置断点 # 问题代码

更现代的替代方案是ipdb，提供更好的交互体验。

13.3 日志调试

在模块中添加日志记录：

import logging logger = logging.getLogger(__name__) def some_function(): try: # 业务逻辑 logger.debug("Debug message") except Exception as e: logger.error(f"Error occurred: {e}") raise

14. 模块与面向对象编程

14.1 模块与类的关系

模块和类都是组织代码的方式，但有不同的适用场景：

1. 模块：组织相关函数和变量
2. 类：封装数据和操作数据的方法

经验法则：

• 如果主要是函数和简单数据，使用模块
• 如果需要维护复杂状态，使用类

14.2 模块中的类设计

在模块中定义类时：

# mymodule.py class MyClass: """类文档字符串""" def __init__(self, param): self.param = param def method(self): """方法文档字符串""" pass # 模块级函数 def module_function(): pass

14.3 单例模式的模块实现

利用模块的天然单例特性：

# singleton.py class _Singleton: def __init__(self): self.value = None instance = _Singleton() def get_instance(): return instance

使用时：

from singleton import get_instance s1 = get_instance() s2 = get_instance() assert s1 is s2 # True

15. 模块与函数式编程

15.1 高阶函数模块

创建包含高阶函数的模块：

# functional.py from typing import Callable, TypeVar, Iterable T = TypeVar('T') def map_reduce( mapper: Callable[[T], T], reducer: Callable[[Iterable[T]], T], items: Iterable[T] ) -> T: """通用的map-reduce实现""" mapped = map(mapper, items) return reducer(mapped)

15.2 装饰器模块

将常用装饰器组织在单独模块中：

# decorators.py import time from functools import wraps def timing(func): """测量函数执行时间的装饰器""" @wraps(func) def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) end = time.time() print(f"{func.__name__} executed in {end-start:.4f}s") return result return wrapper def log_call(func): """记录函数调用的装饰器""" @wraps(func) def wrapper(*args, **kwargs): print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}") return func(*args, **kwargs) return wrapper

16. 模块与元编程

16.1 动态创建模块

使用types模块动态创建模块：

import types # 创建新模块 dynamic_module = types.ModuleType('dynamic_module') dynamic_module.x = 10 dynamic_module.y = 20 def dynamic_func(): print("Hello from dynamic module") dynamic_module.dynamic_func = dynamic_func # 使用动态模块 import sys sys.modules['dynamic_module'] = dynamic_module from dynamic_module import dynamic_func dynamic_func()

16.2 模块属性拦截

通过__getattr__实现模块属性拦截：

# lazy_module.py class _LazyLoader: def __init__(self): self._loaded = False self._heavy_module = None def _load(self): if not self._loaded: import heavy_module # 延迟导入 self._heavy_module = heavy_module self._loaded = True def __getattr__(self, name): self._load() return getattr(self._heavy_module, name) sys.modules[__name__] = _LazyLoader()

17. 模块与并发编程

17.1 线程安全模块

设计线程安全模块的注意事项：

1. 避免共享可变状态
2. 使用线程安全的数据结构
3. 合理使用锁机制

# thread_safe.py import threading class Counter: def __init__(self): self._value = 0 self._lock = threading.Lock() def increment(self): with self._lock: self._value += 1 def value(self): with self._lock: return self._value

17.2 异步模块设计

设计支持asyncio的模块：

# async_module.py import asyncio async def fetch_data(url): # 模拟异步IO操作 await asyncio.sleep(1) return f"Data from {url}" async def process_data(urls): tasks = [fetch_data(url) for url in urls] return await asyncio.gather(*tasks)

18. 模块与C扩展

18.1 使用C扩展模块

Python可以调用C编写的扩展模块，典型场景：

1. 性能关键代码
2. 与C库交互
3. 硬件访问

示例C扩展：

// example.c #include <Python.h> static PyObject* say_hello(PyObject* self, PyObject* args) { const char* name; if (!PyArg_ParseTuple(args, "s", &name)) return NULL; printf("Hello, %s!\n", name); Py_RETURN_NONE; } static PyMethodDef ExampleMethods[] = { {"say_hello", say_hello, METH_VARARGS, "Print greeting"}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef examplemodule = { PyModuleDef_HEAD_INIT, "example", NULL, -1, ExampleMethods }; PyMODINIT_FUNC PyInit_example(void) { return PyModule_Create(&examplemodule); }

18.2 Cython模块

Cython是编写Python扩展模块的更好方式：

# cython_module.pyx def primes(int kmax): cdef int n, k, i cdef int p[1000] result = [] if kmax > 1000: kmax = 1000 k = 0 n = 2 while k < kmax: i = 0 while i < k and n % p[i] != 0: i += 1 if i == k: p[k] = n k += 1 result.append(n) n += 1 return result

19. 模块与Web开发

19.1 Web应用模块组织

典型Web应用的模块结构：

webapp/ ├── app/ # 应用核心 │ ├── __init__.py # 应用工厂 │ ├── models/ # 数据模型 │ ├── routes/ # 路由 │ ├── services/ # 业务逻辑 │ └── utils/ # 工具函数 ├── tests/ # 测试 ├── migrations/ # 数据库迁移 ├── config.py # 配置 ├── requirements.txt # 依赖 └── wsgi.py # WSGI入口

19.2 Flask/Django模块设计

Flask应用模块示例：

# app/__init__.py from flask import Flask def create_app(config_name): app = Flask(__name__) # 加载配置 app.config.from_object(config[config_name]) # 初始化扩展 from .extensions import db, migrate db.init_app(app) migrate.init_app(app, db) # 注册蓝图 from .routes import main_blueprint app.register_blueprint(main_blueprint) return app

20. 模块与数据科学

20.1 数据科学模块组织

数据科学项目的典型模块结构：

datascience/ ├── data/ # 数据文件 ├── notebooks/ # Jupyter笔记本 ├── src/ # 源代码 │ ├── preprocessing/ # 数据预处理 │ ├── features/ # 特征工程 │ ├── models/ # 模型 │ └── evaluation/ # 评估 ├── config.py # 配置 └── main.py # 主程序

20.2 常用数据科学模块

1. 数据处理

   • pandas：数据框操作
   • numpy：数值计算
   • dask：大数据处理

2. 可视化

   • matplotlib：基础绘图
   • seaborn：统计可视化
   • plotly：交互式可视化

3. 机器学习

   • scikit-learn：传统机器学习
   • tensorflow/pytorch：深度学习
   • xgboost：梯度提升树

21. 模块与GUI开发

21.1 GUI应用模块组织

GUI应用的典型模块结构：

gui_app/ ├── assets/ # 资源文件 ├── src/ # 源代码 │ ├── views/ # 视图模块 │ ├── controllers/ # 控制器 │ ├── models/ # 数据模型 │ └── utils/ # 工具函数 ├── main.py # 入口 └── settings.py # 配置

21.2 常用GUI模块

1. Tkinter：Python标准GUI库
2. PyQt/PySide：Qt绑定
3. wxPython：wxWidgets绑定
4. Kivy：跨平台移动应用
5. Dear PyGui：现代轻量级GUI

PyQt模块示例：

# views/main_window.py from PyQt5.QtWidgets import QMainWindow, QLabel class MainWindow(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle("My App") self.label = QLabel("Hello World!") self.setCentralWidget(self.label)

22. 模块与游戏开发

22.1 游戏模块组织

Python游戏开发的典型模块结构：

game/ ├── assets/ # 游戏资源 │ ├── images/ # 图片 │ ├── sounds/ # 音效 │ └── fonts/ # 字体 ├── src/ # 源代码 │ ├── entities/ # 游戏实体 │ ├── levels/ # 关卡设计 │ ├── systems/ # 游戏系统 │ └── utils/ # 工具函数 ├── config.py # 游戏配置 └── main.py # 游戏入口

22.2 常用游戏开发模块

1. Pygame：2D游戏开发
2. Panda3D：3D游戏引擎
3. Arcade：现代2D游戏库
4. PyOpenGL：OpenGL绑定

Pygame模块示例：

# src/entities/player.py import pygame class Player(pygame.sprite.Sprite): def __init__(self, x, y): super().__init__() self.image = pygame.Surface((32, 32)) self.image.fill((255, 0, 0)) self.rect = self.image.get_rect() self.rect.x = x self.rect.y = y self.speed = 5 def update(self, keys): if keys[pygame.K_LEFT]: self.rect.x -= self.speed if keys[pygame.K_RIGHT]: self.rect.x += self.speed

23. 模块与网络编程

23.1 网络应用模块组织

网络应用的典型模块结构：

network_app/ ├── src/ # 源代码 │ ├── client/ # 客户端代码 │ ├── server/ # 服务端代码 │ ├── protocol/ # 协议实现 │ └── utils/ # 工具函数 ├── config.py # 配置 └── main.py # 入口

23.2 常用网络编程模块

1. socket：底层网络接口
2. asyncio：异步网络编程
3. aiohttp：异步HTTP客户端/服务器
4. requests：HTTP客户端
5. websockets：WebSocket实现

异步服务器模块示例：

# src/server/main.py import asyncio import websockets async def handle_connection(websocket, path): async for message in websocket: print(f"Received: {message}") await websocket.send(f"Echo: {message}") async def start_server(): async with websockets.serve(handle_connection, "localhost", 8765): await asyncio.Future() # 永远运行 if __name__ == "__main__": asyncio.run(start_server())

24. 模块与系统管理

24.1 系统工具模块组织

系统管理工具的典型模块结构：

sysadmin_tool/ ├── src/ # 源代码 │ ├── commands/ # CLI命令 │ ├── core/ # 核心功能 │ └── utils/ # 工具函数 ├── setup.py # 安装配置 └── main.py # 入口

24.2 常用系统管理模块

1. os：操作系统接口
2. sys：系统相关功能
3. subprocess：进程管理
4. shutil：文件操作
5. psutil：系统监控

系统监控模块示例：

# src/core/monitor.py import psutil import time def monitor_system(interval=1): """监控系统资源使用情况""" while True: cpu_percent = psutil.cpu_percent(interval=interval) mem = psutil.virtual_memory() print(f"CPU: {cpu_percent}% | Memory: {mem.percent}%") time.sleep(interval)

25. 模块与测试自动化

25.1 测试框架模块组织

测试框架的典型模块结构：

test_framework/ ├── src/ # 源代码 │ ├── runners/ # 测试运行器 │ ├── reporters/ # 报告生成 │ ├── plugins/ # 插件系统 │ └── utils/ # 工具函数 ├── tests/ # 框架自身测试 ├── setup.py # 安装配置 └── main.py # 入口

25.2 常用测试模块

1. unittest：标准测试框架
2. pytest：功能更丰富的框架
3. doctest：文档测试
4. mock：模拟对象
5. coverage：代码覆盖率

自定义测试框架示例：

# src/runners/base.py import time from typing import Callable, List class TestCase: def __init__(self, name: str, func: Callable): self.name = name self.func = func self.passed = False self.duration = 0 def run(self): start = time.time() try: self.func() self.passed = True except AssertionError as e: print(f"Test failed: {self.name} - {e}") except Exception as e: print(f"Error in test {self.name}: {e}") finally: self.duration = time.time() - start class TestRunner: def __init__(self): self.test_cases: List[TestCase] = [] def add_test(self, name: str, func: Callable): self.test_cases.append(TestCase(name, func)) def run_all(self): for test in self.test_cases: test.run() passed = sum(1 for t in self.test_cases if t.passed) total = len(self.test_cases) print(f"\nResults: {passed}/{total} tests passed")

26. 模块与安全编程

26.1 安全工具模块组织

安全工具的典型模块结构：

security_tool/ ├── src/ # 源代码 │ ├── crypto/ # 加密算法 │ ├── auth/ # 认证授权 │ ├── scanner/ # 安全扫描 │ └── utils/ # 工具函数 ├── tests/ # 测试 ├── setup.py # 安装配置 └── main.py # 入口

26.2 常用安全模块

1. hashlib：哈希算法
2. hmac：消息认证
3. ssl：SSL/TLS支持
4. cryptography：现代加密
5. passlib：密码哈希

密码哈希模块示例：

# src/auth/password.py from passlib.context import CryptContext pwd_context = CryptContext( schemes=["bcrypt"], deprecated="auto" ) def verify_password(plain_password: str, hashed_password: str) -> bool: """验证密码""" return pwd_context.verify(plain_password, hashed_password) def get_password_hash(password: str) -> str: """生成密码哈希""" return pwd_context.hash(password)

27. 模块与性能优化

27.1 性能工具模块组织

性能优化工具的典型模块结构：

perf_tool/ ├── src/ # 源代码 │ ├── profilers/ # 性能分析 │ ├── optimizers/ #