代码收藏家技术教程 2025-05-17

Python编程必备库：掌握这些提升技能水平

学习 Python 必须掌握的库

引言

为提高开发效率，避免重复“造轮子”，我们需要掌握使用 Python 系统库和第三方库。本文列举了 Python 从入门到精通必须掌握的库，覆盖以下方面

基础库

数据处理和分析

Web 开发

自动化与系统管理

科学计算与 AI

工具类库

12b433f8-cb2a-46db-b26d-05624c49dc0e

基础库

1. os

os 是 Python 内置的标准库，主要用于与操作系统交互，提供以下核心功能：

文件和目录操作（创建/删除/重命名/遍历）
环境变量管理（读取/设置系统变量）
路径处理（跨平台路径拼接/解析）
执行系统命令（如调用命令行程序）

示例 1：遍历目录并统计文件

import os

def count_files(directory):
    """统计目录下各类文件的数量"""
    ext_counts = {}
    for root, dirs, files in os.walk(directory):
        for file in files:
            ext = os.path.splitext(file)[1]  # 获取文件扩展名
            ext_counts[ext] = ext_counts.get(ext, 0) + 1
    return ext_counts

# 示例：统计当前目录下文件类型
print(count_files('.'))
# 输出：{'.py': 5, '.txt': 3, '.jpg': 2}

关键方法说明：

os.walk()：递归遍历目录树

os.path.splitext()：分离文件名和扩展名

示例 2：跨平台路径拼接与环境变量读取

import os

# 示例1：安全拼接路径（自动处理不同操作系统的斜杠）
config_path = os.path.join('config', 'app', 'settings.ini')
print(f"配置文件路径：{config_path}")
# Windows输出：config\app\settings.ini
# Linux/Mac输出：config/app/settings.ini

# 示例2：读取系统环境变量
print(f"当前用户：{os.getenv('USERNAME') or os.getenv('USER')}")
print(f"PATH变量前3项：{os.getenv('PATH').split(os.pathsep)[:3]}")

关键方法说明：

os.path.join()：跨平台路径拼接

os.getenv()：获取环境变量值

os.pathsep：路径分隔符（Windows是;，Linux/Mac是:）

2. sys

sys 是 Python 内置的标准库，主要用于与 Python 解释器交互，提供以下核心功能：

命令行参数处理（获取脚本运行时传入的参数）
标准输入/输出控制（如重定向 stdin/stdout/stderr）
解释器信息查询（Python 版本、模块搜索路径等）
程序退出控制（强制退出或返回状态码）

示例 1：获取命令行参数

import sys

# 示例：计算传入数字的和
if len(sys.argv) > 1:  # sys.argv[0] 是脚本名
    numbers = [float(arg) for arg in sys.argv[1:]]
    print(f"参数总和：{sum(numbers)}")
else:
    print("请传入数字参数，例如：python script.py 10 20 30")

# 命令行调用示例：
# $ python script.py 5 3.2 7
# 输出：参数总和：15.2

关键变量：

sys.argv：存储命令行参数的列表（字符串格式）

示例 2：修改模块搜索路径

import sys

# 添加自定义模块路径
sys.path.append("/path/to/your/modules")

# 查看当前Python模块搜索路径
print("模块搜索路径：")
for path in sys.path:
    print(f" - {path}")

# 典型输出：
# - /usr/lib/python3.8
# - /path/to/your/modules  ← 新增的路径

关键方法：

sys.path：Python 导入模块时的搜索路径列表

sys.path.append()：动态添加新搜索路径

3. dateutil

dateutil 是 Python 的第三方日期时间处理库（python-dateutil），扩展了标准库 datetime 的功能，主要解决以下问题：

灵活解析日期字符串：自动识别多种日期格式（如 "2023-12-25"、"Jan 1, 2024"、"3 days ago"）
复杂时间计算：支持相对时间（如“下个月的第2个周五”）
时区处理：比 datetime 更简单的时区转换

示例 1：智能解析日期字符串

from dateutil.parser import parse

# 自动识别不同格式的日期
date1 = parse("2023-12-25")           # 标准格式
date2 = parse("Jan 1, 2024 5:30PM")  # 含英文月份和12小时制
date3 = parse("3 days ago")           # 相对时间

print(date1)  # 2023-12-25 00:00:00
print(date2)  # 2024-01-01 17:30:00
print(date3)  # 当前时间 - 3天

关键函数：

parse()：自动解析人类可读的日期字符串

示例 2：计算相对时间（如“下个月的第2个周五”）

from dateutil.relativedelta import relativedelta
from dateutil.rrule import rrule, WEEKLY, FR

# 获取当前日期
from datetime import datetime
today = datetime.now()

# 计算下个月的第2个周五
next_month = today + relativedelta(months=1)
second_friday = list(rrule(
    WEEKLY,
    byweekday=FR,      # 周五
    count=2,           # 取2个周五
    dtstart=next_month.replace(day=1)  # 从下个月1号开始算
))[1]  # 取第2个结果

print(f"下个月的第2个周五是: {second_friday.strftime('%Y-%m-%d')}")

关键功能：

relativedelta：处理月份/年份的增减（自动处理不同月份的天数差异）

rrule：生成重复时间规则（类似日历循环事件）

典型应用场景：

日志分析（解析不同格式的时间戳）

生成定期报告（如“每月最后一个工作日”）

处理用户输入的自然语言日期

4. json

json 是 Python 内置的标准库，用于处理 JSON（JavaScript Object Notation）数据格式，主要功能包括：

序列化（编码）：将 Python 对象（字典、列表等）转换为 JSON 字符串
反序列化（解码）：将 JSON 字符串解析为 Python 对象
跨语言数据交换： JSON 是通用的数据格式，支持与 JavaScript/Java/PHP 等语言交互

核心方法

方法	作用
`json.dumps()`	将 Python 对象转为 JSON 字符串
`json.loads()`	将 JSON 字符串转为 Python 对象
`json.dump()`	将 Python 对象写入 JSON 文件
`json.load()`	从 JSON 文件读取数据

示例 1：Python 对象 ↔ JSON 字符串

import json

# Python 字典 → JSON 字符串
data = {
    "name": "张三",
    "age": 30,
    "skills": ["Python", "SQL"]
}
json_str = json.dumps(data, ensure_ascii=False, indent=2)  # 禁用ASCII转码，美化格式
print(json_str)

输出：

{
  "name": "张三",
  "age": 30,
  "skills": ["Python", "SQL"]
}

JSON 字符串 → Python 对象

 parsed_data = json.loads('{"city": "北京", "population": 2171}')
 print(parsed_data["city"])  # 输出：北京

示例 2：JSON 文件读写

```python
import json

写入 JSON 文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump({"temperature": 25.7, "humidity": 60}, f)

读取 JSON 文件
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)
    print(f"当前温度：{data['temperature']}℃")  # 输出：当前温度：25.7℃

参数说明：

ensure_ascii=False：允许非ASCII字符（如中文）直接显示

indent=2：格式化缩进，方便阅读

文件操作对比：

操作	内存对象 → 文件	文件 → 内存对象
函数	`json.dump(obj, f)`	`json.load(f)`
字符串	`json.dumps(obj)`	`json.loads(str)`

常见应用场景

API 数据交互

import requests
response = requests.get("https://api.example.com/data")
data = json.loads(response.text)

配置文件存储

# 保存配置
config = {"theme": "dark", "font_size": 14}
with open("config.json", "w") as f:
    json.dump(config, f)

跨语言数据共享：与前端 JavaScript 通过 JSON 传递数据

5. logging

logging 是 Python 内置的日志记录库，用于程序运行时的信息记录、错误追踪和状态监控。相比直接使用 print()，它提供以下核心优势：

分级日志：支持 DEBUG/INFO/WARNING/ERROR/CRITICAL 5个日志级别
灵活输出：可同时输出到控制台、文件、邮件等
自动附加信息：记录时间、模块名、行号等上下文
线程安全：适合多线程/多进程环境

示例 1：基础日志配置（输出到控制台）

import logging

# 配置日志格式和级别
logging.basicConfig(
    level=logging.INFO,  # 只记录INFO及以上级别
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# 记录不同级别日志
logging.debug("调试信息（不会显示）")  # 低于INFO级别
logging.info("程序启动完成")
logging.warning("磁盘空间不足")
logging.error("数据库连接失败")

# 输出示例：
# 2023-12-25 14:30:00,123 - root - INFO - 程序启动完成
# 2023-12-25 14:30:00,124 - root - WARNING - 磁盘空间不足

关键参数说明：

level：过滤日志级别（DEBUG < INFO < WARNING < ERROR < CRITICAL）

format：

%(asctime)s：时间

%(name)s：日志器名称

%(levelname)s：日志级别

示例 2：高级用法（日志同时写入文件和控制台）

import logging

# 创建日志器
logger = logging.getLogger("my_app")
logger.setLevel(logging.DEBUG)  # 捕获所有级别

# 文件处理器（每天一个日志文件）
from logging.handlers import TimedRotatingFileHandler
file_handler = TimedRotatingFileHandler(
    filename="app.log",
    when="midnight",  # 每天午夜切割
    backupCount=7     # 保留7天日志
)
file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))

# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)  # 控制台只显示INFO及以上

# 添加处理器
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 使用日志
logger.debug("详细调试信息")  # 仅写入文件
logger.info("用户登录成功")   # 同时写入文件和控制台

运行结果：

控制台输出：

2023-12-25 14:35:00 - INFO - 用户登录成功

文件 app.log 内容：

2023-12-25 14:35:00 - DEBUG - 详细调试信息
2023-12-25 14:35:00 - INFO - 用户登录成功

实际应用场景

Web服务错误监控

try:
    response = requests.get(url)
except Exception as e:
    logging.error(f"API请求失败: {e}", exc_info=True)  # 记录异常堆栈

定时任务日志归档

from logging.handlers import RotatingFileHandler
handler = RotatingFileHandler("task.log", maxBytes=10 * 1024 * 1024, backupCount=5)  # 单个文件10MB，保留5个

动态调整日志级别

logging.getLogger().setLevel(logging.DEBUG if debug_mode else logging.INFO)

数据处理与分析

1. NumPy

NumPy（Numerical Python）是 Python 的核心科学计算库，主要用于高效处理多维数组和矩阵运算。其核心功能包括：

高性能数组：提供 ndarray 数据结构，比原生 Python 列表快 10-100 倍
数学运算：内置向量化操作（避免显式循环）
广播机制：支持不同形状数组的自动对齐计算
线性代数/随机数生成：提供矩阵运算、傅里叶变换等高级数学工具

示例 1：基础数组操作

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])  # 一维数组
matrix = np.array([[1, 2], [3, 4]])  # 二维矩阵

# 向量化运算（无需循环）
print(arr * 2)          # 输出：[ 2  4  6  8 10]
print(matrix + 10)      # 输出：[[11 12] [13 14]]

# 常用属性
print(arr.shape)        # 输出：(5,) （数组形状）
print(matrix.dtype)     # 输出：int64 （数据类型）

示例 2：科学计算实战

import numpy as np

# 生成随机数据（1000个正态分布样本）
data = np.random.normal(0, 1, 1000)  # 均值=0，标准差=1

# 统计计算
print(f"均值: {np.mean(data):.2f}")    # 输出：均值: 0.02
print(f"标准差: {np.std(data):.2f}")   # 输出：标准差: 1.01

# 矩阵运算
A = np.array([[1, 2], [3, 4]])
B = np.eye(2)  # 2x2单位矩阵
print(A @ B)   # 矩阵乘法，输出：[[1. 2.] [3. 4.]]
print(np.linalg.inv(A))  # 矩阵求逆，输出：[[-2.   1. ] [ 1.5 -0.5]]

典型应用场景：

机器学习数据预处理（如归一化）

图像处理（3D 数组表示 RGB 通道）

金融模型计算（蒙特卡洛模拟）

2. pandas

pandas 是 Python 的核心数据分析库，主要用于结构化数据的快速处理和分析。其核心功能包括：

表格数据处理：提供 DataFrame（二维表）和 Series（一维列）数据结构
数据清洗：处理缺失值、去重、类型转换等
高效查询：支持类似 SQL 的筛选、分组、聚合操作
时间序列处理：专门优化针对时间数据的操作
数据输入/输出：支持 CSV/Excel/SQL/JSON 等多种数据格式

示例 1：数据清洗与分析

import pandas as pd

# 从CSV创建DataFrame
df = pd.read_csv("sales.csv")
print(df.head(3))  # 显示前3行

# 数据清洗
clean_df = df.dropna()  # 删除空值行
clean_df["profit"] = clean_df["revenue"] - clean_df["cost"]  # 新增列

# 分析数据
top_products = clean_df.groupby("product")["profit"].sum().sort_values(ascending=False)
print("利润最高的产品：\n", top_products.head())

输出示例：

   product  revenue   cost
0    Phone     1200    800
1   Laptop     1500   1000
2    Phone      900    600

利润最高的产品：
product
Laptop    500
Phone     700

示例 2：时间序列处理

# 创建时间序列数据
date_rng = pd.date_range(start="2023-01-01", end="2023-01-10", freq="D")
sales_data = pd.DataFrame({
    "date": date_rng,
    "sales": [100, 120, 90, 150, None, 200, 180, 130, 160, 110]
})

# 处理时间序列
sales_data = sales_data.set_index("date")  # 将日期设为索引
sales_data = sales_data.fillna(method="ffill")  # 用前一天数据填充空值

# 计算7天移动平均
sales_data["7d_avg"] = sales_data["sales"].rolling(7).mean()
print(sales_data.tail(3))

输出示例：

            sales    7d_avg
date                       
2023-01-08    130  	135.714
2023-01-09    160  	138.571
2023-01-10    110  	132.857

3. openpyxl

openpyxl 是 Python 中用于读写 Excel 文件（.xlsx 格式）的库，主要功能包括：

读写 Excel 文件：支持 .xlsx 格式（不支持旧的 .xls 格式）
操作工作表：创建、删除、复制工作表
单元格级操作：读取/修改单元格数据、样式（字体、颜色、边框等）
公式计算：支持 Excel 公式（如 SUM、VLOOKUP）
图表生成：可创建柱状图、折线图等

示例 1：读取 Excel 文件

from openpyxl import load_workbook

# 加载现有 Excel 文件
wb = load_workbook("example.xlsx")  
sheet = wb.active  # 获取当前活动工作表

# 读取单元格数据
print(f"A1 单元格的值: {sheet['A1'].value}")

# 遍历所有数据
for row in sheet.iter_rows(values_only=True):
    print(row)  # 每行以元组形式输出

# 输出示例：
# A1 单元格的值: 姓名
# ('姓名', '年龄', '城市')
# ('张三', 25, '北京')
# ('李四', 30, '上海')

关键方法：

load_workbook()：加载现有 Excel 文件

sheet.iter_rows()：按行迭代数据

示例 2：创建并格式化 Excel 文件

from openpyxl import Workbook
from openpyxl.styles import Font, Alignment

# 创建新工作簿
wb = Workbook()
sheet = wb.active
sheet.title = "员工信息"  # 修改工作表名称

# 写入表头（加粗+居中）
header = ["姓名", "部门", "工资"]
sheet.append(header)
for cell in sheet[1]:  # 第一行是表头
    cell.font = Font(bold=True)
    cell.alignment = Alignment(horizontal="center")

# 写入数据
data = [
    ["张三", "技术部", 15000],
    ["李四", "市场部", 12000]
]
for row in data:
    sheet.append(row)

# 保存文件
wb.save("employees.xlsx")

生成文件效果：

姓名（加粗居中）	部门（加粗居中）	工资（加粗居中）
张三	技术部	15000
李四	市场部	12000

4. SQLAlchemy

SQLAlchemy 是 Python 的 ORM（对象关系映射）工具和 SQL 工具包，核心功能包括：

ORM 模式：将数据库表映射为 Python 类，行记录映射为对象。用 Python 语法操作数据库，无需直接写 SQL。
SQL 表达式语言：提供比原生 SQL 更安全的查询构建方式。
数据库兼容：支持 PostgreSQL/MySQL/SQLite/Oracle 等主流数据库。
连接池管理：自动管理数据库连接，提升性能。

适用场景：Web 后端开发、数据分析管道、需要数据库交互的脚本

示例 1：ORM 模式（定义表结构并操作数据）

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

# 1. 定义基类和表结构
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    age = Column(Integer)

# 2. 连接数据库（SQLite）
engine = create_engine('sqlite:///example.db')
Base.metadata.create_all(engine)  # 创建表

# 3. 操作数据
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_user = User(name='张三', age=25)
session.add(new_user)
session.commit()

# 查询数据
users = session.query(User).filter(User.age > 20).all()
for u in users:
    print(u.id, u.name, u.age)

关键步骤：

declarative_base() 创建 ORM 基类
Column 定义字段类型
session 管理数据库会话

示例 2：SQL 表达式语言（直接执行 SQL 语句）

from sqlalchemy import text
from sqlalchemy import create_engine

# 连接 MySQL
engine = create_engine("mysql+pymysql://user:password@localhost/mydb")

# 执行原生 SQL
with engine.connect() as conn:
    # 插入数据
    conn.execute(text("INSERT INTO products (name, price) VALUES (:name, :price)"), 
                 {"name": "笔记本电脑", "price": 5999})
    
    # 参数化查询（防 SQL 注入）
    result = conn.execute(
        text("SELECT * FROM products WHERE price > :min_price"),
        {"min_price": 1000}
    )
    for row in result:
        print(row.name, row.price)

安全特性：

text() 包装 SQL 语句

:param 参数化查询防止注入

Web 开发

1. flask

Flask 是 Python 的轻量级 Web 框架，核心功能包括：

路由管理：将 URL 路径映射到 Python 函数（如 /hello → hello()）
请求-响应处理：解析 HTTP 请求（GET/POST 等），生成响应（HTML/JSON/文件等）
模板渲染：使用 Jinja2 引擎动态生成 HTML
扩展生态：可通过插件添加数据库、认证、API 等功能

适用场景：快速开发小型 Web 应用、微服务、API 接口

示例 1：基础 Web 应用（返回 HTML/JSON）

from flask import Flask, jsonify

app = Flask(__name__)

# 路由：根路径返回 HTML
@app.route("/")
def home():
    return "<h1>欢迎访问首页！</h1>"

# 路由：API 接口返回 JSON
@app.route("/api/user/<username>")
def user_info(username):
    return jsonify(
        username=username,
        role="admin" if username == "admin" else "user"
    )

if __name__ == "__main__":
    app.run(debug=True)  # 启动开发服务器

运行效果：

访问 http://127.0.0.1:5000/ → 显示 HTML 标题
访问 http://127.0.0.1:5000/api/user/alice → 返回 JSON：

{"username": "alice", "role": "user"}

示例 2：表单处理 + 模板渲染

from flask import Flask, render_template, request

app = Flask(__name__)

# 渲染表单页面（GET 请求）
@app.route("/login", methods=["GET"])
def login_form():
    return render_template("login.html")  # 模板文件需放在 templates/ 目录下

# 处理表单提交（POST 请求）
@app.route("/login", methods=["POST"])
def login():
    username = request.form.get("username")
    password = request.form.get("password")
    if username == "admin" and password == "123456":
        return f"<h2>欢迎, {username}!</h2>"
    else:
        return "<h2>登录失败</h2>"

if __name__ == "__main__":
    app.run()

模板文件 templates/login.html：

<form method="POST">
  <input type="text" name="username" placeholder="用户名" required>
  <input type="password" name="password" placeholder="密码" required>
  <button type="submit">登录</button>
</form>

关键功能：

request.form 获取 POST 表单数据

render_template 渲染 Jinja2 模板

2. Django

Django 是 Python 的高层次全功能 Web 框架，遵循 “Batteries Included”（开箱即用）设计理念，核心功能包括：

快速开发：内置 ORM、Admin 后台、用户认证等组件
MVC 架构：严格遵循 Model-View-Template 模式（Django 中称为 MTV）
安全防护：自动处理 SQL 注入、XSS、CSRF 等安全问题
可扩展性：支持从博客系统到企业级复杂应用

适用场景：内容管理系统（CMS）、社交网站、数据驱动的复杂 Web 应用

示例 1：创建博客应用（模型 + 后台管理）

创建项目和应用

django-admin startproject myblog
cd myblog
python manage.py startapp blog

定义模型（blog/models.py）

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

启用 Admin 后台（blog/admin.py）

from django.contrib import admin
from .models import Post

admin.site.register(Post)

运行开发服务器

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser  # 创建管理员账号
python manage.py runserver

访问 http://127.0.0.1:8000/admin 可管理博客文章：
https://docs.djangoproject.com/en/4.2/_images/admin01.png

示例 2：构建 REST API（Django REST framework）

安装 DRF

pip install djangorestframework

创建 API（blog/serializers.py）

from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ['id', 'title', 'content', 'created_at']

编写视图（blog/views.py）

from rest_framework import generics
from .models import Post
from .serializers import PostSerializer

class PostListAPIView(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

配置路由（blog/urls.py）

from django.urls import path
from .views import PostListAPIView

urlpatterns = [
    path('api/posts/', PostListAPIView.as_view()),
]

访问 http://127.0.0.1:8000/api/posts/ 获取 JSON 格式的文章列表：

[
    {
        "id": 1,
        "title": "First Post",
        "content": "Hello Django!",
        "created_at": "2023-12-25T00:00:00Z"
    }
]

3. FastAPI

FastAPI 是一个现代、快速（高性能）的 Python Web 框架，专门用于构建 API（如 RESTful API、WebSocket 等），核心优势包括：

极高性能：基于 Starlette（异步框架）和 Pydantic（数据验证），速度接近 Node.js 和 Go
自动文档生成：内置 Swagger UI 和 ReDoc，自动生成交互式 API 文档
类型提示支持：利用 Python 类型注解（Type Hints）实现数据验证和编辑器智能提示
异步支持：原生支持 async/await，适合高并发场景（如爬虫、实时通信）

适用场景：微服务、数据接口、机器学习模型部署、实时应用

示例 1：基础 REST API（自动文档+数据验证）

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# 定义数据模型
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None  # 可选字段

# 路由：GET 请求
@app.get("/")
def read_root():
    return {"message": "Hello FastAPI"}

# 路由：带路径参数的 GET
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# 路由：POST 请求（自动验证请求体）
@app.post("/items/")
def create_item(item: Item):
    return {"item_name": item.name, "price": item.price}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

运行后访问：

API 文档：http://127.0.0.1:8000/docs（Swagger UI）
https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png
直接测试接口：http://127.0.0.1:8000/items/5?q=test

示例 2：异步数据库查询（MySQL + SQLAlchemy）

from fastapi import FastAPI, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
import os

# 配置数据库（异步MySQL驱动）
DATABASE_URL = "mysql+asyncmy://user:password@localhost/dbname"
engine = create_async_engine(DATABASE_URL)
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession)

Base = declarative_base()

# 定义模型
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50))

app = FastAPI()

# 异步获取用户
@app.get("/users/{user_id}")
async def get_user(user_id: int):
    async with AsyncSessionLocal() as session:
        user = await session.get(User, user_id)
        if not user:
            raise HTTPException(status_code=404, detail="User not found")
        return {"id": user.id, "name": user.name}

# 创建表（实际项目应使用 Alembic 迁移）
@app.on_event("startup")
async def init_db():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

关键点：

使用 asyncmy 或 asyncpg 等异步数据库驱动

通过 AsyncSession 实现非阻塞查询

4. BeautifulSoup4

BeautifulSoup4（简称 bs4）是 Python 的 HTML/XML 解析库，主要用于从网页中提取结构化数据。其核心功能包括：

解析混乱的 HTML：自动修复缺失的标签（如 <p> 未闭合）
灵活的节点查找：支持通过标签名、CSS 类、ID、属性等定位元素
树形结构导航：可遍历父节点、子节点、兄弟节点
与请求库无缝集成：常配合 requests 或 urllib 使用

适用场景：网页爬虫、数据抓取、内容分析

示例 1：解析静态网页（提取标题和链接）

import requests
from bs4 import BeautifulSoup

# 获取网页内容
url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")  # 使用内置的 html.parser

# 提取所有 <a> 标签的链接和文本
for link in soup.find_all("a"):
    print(f"文本: {link.text.strip()}")
    print(f"链接: {link.get('href')}\n")

# 提取特定类的元素
featured = soup.find("div", class_="featured")
if featured:
    print("特色内容:", featured.text)

输出示例：

文本: 首页
链接: /index.html

文本: 关于我们
链接: /about.html

示例 2：处理动态生成的内容（配合 CSS 选择器）

from bs4 import BeautifulSoup

# 假设这是 JavaScript 动态生成的 HTML
html = """
<html>
  <body>
    <ul id="products">
      <li class="product" data-price="299">笔记本 <span>库存: 5</span></li>
      <li class="product" data-price="599">手机 <span>库存: 2</span></li>
    </ul>
  </body>
</html>
"""

soup = BeautifulSoup(html, "lxml")  # 需要安装 lxml: pip install lxml

# 使用 CSS 选择器提取商品信息
products = soup.select("#products .product")
for product in products:
    name = product.contents[0].strip()  # 获取第一个文本节点
    price = product["data-price"]
    stock = product.span.text.split(":")[1].strip()
    print(f"{name} | 价格: {price}元 | 库存: {stock}")

输出结果：

笔记本 | 价格: 299元 | 库存: 5
手机 | 价格: 599元 | 库存: 2

核心方法对比

方法	等效 CSS 选择器	用途
`soup.find("div")`	`div`	查找第一个 div 标签
`soup.find_all("p")`	`p`	查找所有 p 标签
`soup.select(".header")`	`.header`	查找 class=“header” 的元素
`soup.select("#main")`	`#main`	查找 id=“main” 的元素
`soup.find("a", href=True)`	`a[href]`	查找带 href 属性的 a 标签

自动化与系统管理

1. Selenium

Selenium 是 Python 的浏览器自动化工具，主要用于：

Web 自动化测试：模拟用户操作（点击、输入、滚动等）
动态网页数据抓：获取 JavaScript 渲染后的页面内容
跨浏览器兼容性测试：支持 Chrome/Firefox/Edge/Safari 等主流浏览器
处理复杂交互：文件上传、弹窗处理、Cookie 管理等

适用场景：需要与浏览器交互的自动化任务，如爬取动态内容、自动化表单提交、UI 测试等

示例 1：自动登录网站

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

# 启动 Chrome 浏览器
driver = webdriver.Chrome()  # 需确保 chromedriver 在 PATH 中

# 打开登录页面
driver.get("https://example.com/login")

# 定位元素并操作
driver.find_element(By.ID, "username").send_keys("your_username")
driver.find_element(By.ID, "password").send_keys("your_password" + Keys.RETURN)

# 验证登录成功
assert "Dashboard" in driver.title

# 关闭浏览器
driver.quit()

关键方法：

find_element(By.XX, "value")：定位元素（支持 ID/CLASS/XPATH 等）

send_keys()：模拟键盘输入

Keys.RETURN：模拟回车键

示例 2：抓取动态加载的数据

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://quotes.toscrape.com/scroll")

# 等待页面加载并滚动到底部
wait = WebDriverWait(driver, 10)
while True:
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    try:
        # 等待“加载更多”按钮出现
        element = wait.until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".load-more"))
        )
        element.click()
    except:
        break  # 没有更多内容时退出循环

# 提取所有名言
quotes = driver.find_elements(By.CLASS_NAME, "quote")
for quote in quotes:
    print(quote.find_element(By.CLASS_NAME, "text").text)

driver.quit()

输出示例：

"The world as we have created it is a process of our thinking..."
"Life is what happens when you're busy making other plans..."

关键功能：

WebDriverWait：显式等待元素加载

execute_script()：执行 JavaScript 代码（如滚动页面）

expected_conditions：定义等待条件（如元素可见、可点击等）

2. PyAutoGUI

PyAutoGUI 是 Python 的跨平台 GUI 自动化库，主要用于模拟鼠标、键盘操作和屏幕交互，核心功能包括：

鼠标控制：移动、点击、拖拽、滚动
键盘操作：输入文本、快捷键组合、特殊按键（如 Ctrl+C）
屏幕处理：截图、定位图像位置（如按钮图标）
简单OCR：结合 pytesseract 识别屏幕文字

适用场景：自动化重复性桌面任务、游戏脚本、GUI 测试、批量处理等

示例 1：自动打开画图软件并绘图

import pyautogui
import time

# 安全设置：当鼠标移动到屏幕角落时终止程序
pyautogui.FAILSAFE = True

# 打开 Windows 画图软件
pyautogui.hotkey('win', 'r')  # Win+R 打开运行窗口
pyautogui.write('mspaint')    # 输入程序名
pyautogui.press('enter')      # 回车确认
time.sleep(2)                 # 等待画图软件启动

# 选择画笔工具
pyautogui.click(x=100, y=200)  # 点击画笔图标位置（需根据实际屏幕调整坐标）

# 绘制三角形
pyautogui.dragTo(300, 200, duration=0.5)  # 向右拖动
pyautogui.dragTo(200, 400, duration=0.5)  # 向下拖动
pyautogui.dragTo(100, 200, duration=0.5)   # 向左上拖动

关键方法：

hotkey()：组合键（如 Ctrl+C）

write()：模拟键盘输入

dragTo()：按住拖动

示例 2：自动化批量截图并保存

import pyautogui
import time

# 定义截图区域 (left, top, width, height)
region = (0, 0, 800, 600)

for i in range(3):
    # 截图并保存
    screenshot = pyautogui.screenshot(region=region)
    screenshot.save(f'screenshot_{i}.png')
    
    # 模拟滚动（向下滚动3次）
    pyautogui.scroll(-500)  # 负数表示向下滚动
    time.sleep(1)

# 定位屏幕上特定图像（如按钮图标）
button_pos = pyautogui.locateOnScreen('button.png', confidence=0.8)
if button_pos:
    pyautogui.click(button_pos)

关键功能：

screenshot()：截取屏幕或指定区域

locateOnScreen()：图像匹配定位（需提前保存目标图片）

confidence 参数：匹配相似度阈值（0~1）

3. Paramiko

Paramiko 是 Python 的 SSHv2 协议库，用于安全地连接远程服务器并执行操作，核心功能包括：

远程命令执行：在 Linux/Windows 服务器上运行 Shell 命令
文件传输：通过 SFTP 上传/下载文件
端口转发：建立 SSH 隧道实现加密通信
密钥认证：支持密码和公私钥登录

适用场景：服务器批量管理、自动化运维、CI/CD 部署、网络设备配置

示例 1：执行远程命令（获取服务器信息）

import paramiko

# 创建SSH客户端
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())  # 自动接受未知主机密钥

# 连接服务器（密码认证）
ssh.connect(
    hostname="192.168.1.100",
    port=22,
    username="root",
    password="your_password"
)

# 执行命令
stdin, stdout, stderr = ssh.exec_command("df -h && free -m")
print(stdout.read().decode())  # 打印磁盘和内存使用情况

# 关闭连接
ssh.close()

输出示例：

Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   20G   30G  40% /
mem:           7982   512   7470   6% free

示例 2：SFTP 文件传输（上传/下载）

import paramiko

# 建立SSH连接
transport = paramiko.Transport(("192.168.1.100", 22))
transport.connect(username="user", password="password")

# 创建SFTP客户端
sftp = paramiko.SFTPClient.from_transport(transport)

# 上传本地文件到远程服务器
sftp.put("local_file.txt", "/remote/path/file.txt")

# 下载远程文件到本地
sftp.get("/remote/path/data.csv", "local_data.csv")

# 关闭连接
sftp.close()
transport.close()

关键方法：

put()：上传文件

get()：下载文件

listdir()：列出远程目录

4. psutil

psutil（Process and System Utilities）是 Python 的跨平台系统监控库，用于获取系统和进程的运行信息，核心功能包括：

系统资源监控： CPU、内存、磁盘、网络等实时使用情况
进程管理：获取进程列表、资源占用、终止进程等
跨平台支持：兼容 Windows、Linux、macOS 等操作系统
低开销：直接调用系统原生接口，性能高效

适用场景：系统监控工具、性能分析、资源告警、任务管理器开发

示例 1：监控系统资源（CPU/内存/磁盘）

import psutil

# 获取 CPU 信息
print(f"CPU 核心数: {psutil.cpu_count(logical=False)} (物理), {psutil.cpu_count()} (逻辑)")
print(f"CPU 使用率: {psutil.cpu_percent(interval=1)}%")  # 1秒内的平均使用率

# 获取内存信息
mem = psutil.virtual_memory()
print(f"内存总量: {mem.total / 1024 ** 3:.2f} GB")
print(f"内存使用率: {mem.percent}%")

# 获取磁盘信息
disk = psutil.disk_usage('/')
print(f"磁盘总量: {disk.total / 1024 ** 3:.2f} GB")
print(f"磁盘使用率: {disk.percent}%")

输出示例：

CPU 核心数: 4 (物理), 8 (逻辑)
CPU 使用率: 15.5%
内存总量: 15.62 GB
内存使用率: 34.2%
磁盘总量: 465.76 GB
磁盘使用率: 72.1%

示例 2：监控进程并终止占用高的进程

import psutil

# 获取所有进程信息
for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
    if proc.info['cpu_percent'] > 10:  # CPU占用超过10%的进程
        print(f"高CPU进程: PID={proc.info['pid']}, 名称={proc.info['name']}, CPU={proc.info['cpu_percent']}%")

    if proc.info['memory_percent'] > 5:  # 内存占用超过5%的进程
        print(f"高内存进程: PID={proc.info['pid']}, 名称={proc.info['name']}, 内存={proc.info['memory_percent']}%")

# 终止指定进程（例如PID=1234）
try:
    p = psutil.Process(1234)
    p.terminate()  # 终止进程
    print(f"已终止进程: {p.name()}")
except psutil.NoSuchProcess:
    print("进程不存在")

关键方法：

process_iter()：遍历所有进程

cpu_percent() / memory_percent()：进程资源占用

terminate()：终止进程

科学计算与AI

1. Matplotlib

Matplotlib 是 Python 的核心数据可视化库，用于创建高质量的静态、动态和交互式图表，核心功能包括：

2D/3D 图表绘制：折线图、柱状图、散点图、饼图、热力图等
高度可定制化：调整颜色、标签、图例、网格等样式
多输出格式支持：导出为 PNG/PDF/SVG 等格式
与其他库无缝集成：与 NumPy、Pandas、SciPy 协同工作

适用场景：数据分析报告、学术论文图表、机器学习结果可视化

示例 1：绘制折线图与柱状图

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建画布和子图
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

# 折线图
ax1.plot(x, y, color='red', linestyle='--', label='sin(x)')
ax1.set_title("Sine Wave")
ax1.set_xlabel("X-axis")
ax1.set_ylabel("Y-axis")
ax1.legend()

# 柱状图
categories = ['A', 'B', 'C']
values = [15, 25, 10]
ax2.bar(categories, values, color=['blue', 'green', 'orange'])
ax2.set_title("Bar Chart")

plt.tight_layout()  # 自动调整子图间距
plt.savefig("combined_plot.png")  # 保存为图片
plt.show()

示例 2：绘制多子图与3D图形

from mpl_toolkits.mplot3d import Axes3D

# 创建画布
fig = plt.figure(figsize=(10, 5))

# 子图1：散点图
ax1 = fig.add_subplot(121)
x = np.random.rand(50)
y = x + np.random.rand(50) * 0.1
ax1.scatter(x, y, color='purple', alpha=0.6)
ax1.set_title("Scatter Plot")

# 子图2：3D曲面
ax2 = fig.add_subplot(122, projection='3d')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))
ax2.plot_surface(X, Y, Z, cmap='viridis')
ax2.set_title("3D Surface")

plt.tight_layout()
plt.show()

2. scikit-learn

Scikit-learn 库的作用
scikit-learn 是 Python 的核心机器学习库，提供统一的 API 实现以下功能：

监督学习：分类（如 SVM、随机森林）、回归（如线性回归、决策树回归）。
无监督学习：聚类（如 K-Means、DBSCAN）、降维（如 PCA、t-SNE）。
数据预处理：标准化、缺失值填充、特征编码。
模型评估：交叉验证、性能指标（准确率、F1-score 等）。

📌 特点：

接口统一（fit()/predict() 方法）

与 NumPy/Pandas 无缝集成

适合中小规模数据（大数据推荐用 Spark MLlib）

示例 1：鸢尾花分类（监督学习）

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 划分训练集/测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 训练模型
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)

# 预测并评估
y_pred = clf.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred):.2f}")

# 输出特征重要性
print("特征重要性:", clf.feature_importances_)

输出示例：

准确率: 0.97
特征重要性: [0.11 0.02 0.42 0.45]

示例 2：手写数字降维（无监督学习）

from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# 加载手写数字数据集（8x8像素图像）
digits = load_digits()
X = digits.data  # 64维特征（8x8展平）

# 用PCA降维到2D
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 可视化
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=digits.target, alpha=0.6, cmap='tab10')
plt.colorbar(label='数字类别')
plt.xlabel("PCA 主成分1")
plt.ylabel("PCA 主成分2")
plt.title("手写数字PCA降维")
plt.show()

3. tensorflow`/`pytorch

TensorFlow 和 PyTorch 是 Python 的深度学习框架，用于构建和训练神经网络，核心功能包括：

张量计算：支持 GPU/TPU 加速的高性能数值计算。
自动微分：自动计算梯度（反向传播）。
神经网络构建：提供预定义层（卷积层、LSTM 等）和损失函数。
模型部署：支持导出到移动端/嵌入式设备（TensorFlow Lite）。

📌 适用场景：图像识别、自然语言处理、强化学习、科学计算

TensorFlow 示例
示例 1：MNIST 手写数字分类

import tensorflow as tf
from tensorflow.keras import layers

# 加载数据
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 28 * 28).astype('float32') / 255  # 归一化

# 构建模型
model = tf.keras.Sequential([
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 训练
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)

# 评估
loss, acc = model.evaluate(x_test.reshape(-1, 28 * 28), y_test)
print(f"测试集准确率: {acc:.2f}")

输出：

Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step
测试集准确率: 0.97

示例 2：图像生成（GAN）

# 生成器网络
generator = tf.keras.Sequential([
    layers.Dense(7 * 7 * 256, use_bias=False),
    layers.BatchNormalization(),
    layers.LeakyReLU(),
    layers.Reshape((7, 7, 256)),
    layers.Conv2DTranspose(128, (5,5), strides=(1,1), padding='same'),
    layers.Conv2DTranspose(64, (5,5), strides=(2,2), padding='same'),
    layers.Conv2DTranspose(1, (5,5), strides=(2,2), padding='same', activation='tanh')
])

# 生成随机图像
noise = tf.random.normal([1, 100])
generated_image = generator(noise, training=False)
plt.imshow(generated_image[0, :, :, 0], cmap='gray')

PyTorch 示例
示例 1：线性回归

import torch
import torch.nn as nn

# 数据准备
X = torch.tensor([[1], [2], [3]], dtype=torch.float32)
Y = 2 * X + 1  # 真实关系: y=2x+1

# 定义模型
model = nn.Linear(1, 1)
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练
for epoch in range(100):
    y_pred = model(X)
    loss = criterion(y_pred, Y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

print(f"权重: {model.weight.item():.2f}, 偏置: {model.bias.item():.2f}")

输出：

权重: 2.00, 偏置: 1.00

示例 2：图像分类（ResNet）

import torchvision.models as models

# 加载预训练模型
resnet = models.resnet18(pretrained=True)

# 预测示例图像
from PIL import Image
img = Image.open('cat.jpg').resize((224,224))
img_tensor = torchvision.transforms.ToTensor()(img).unsqueeze(0)

# 推理
output = resnet(img_tensor)
print(f"预测类别: {torch.argmax(output)}")

核心对比

特性	TensorFlow	PyTorch
开发公司	Google	Facebook
计算图	静态图（默认）	动态图（更灵活）
部署能力	强（TF Serving/Lite）	需转换（TorchScript）
学术界使用率	30%	70%
代码风格	声明式	命令式

4. OpenCV-Python

OpenCV-Python 是计算机视觉的核心库，提供 2500+ 优化算法，核心功能包括：

图像处理：滤波、边缘检测、直方图操作
视频分析：运动检测、对象跟踪
特征提取： SIFT、ORB、人脸关键点检测
机器学习集成：支持 K-Means、SVM 等算法
硬件加速：支持 CUDA 和 OpenCL

特点：

C++ 底层加速，Python 接口易用

实时性能优异（可达 100+ FPS）

跨平台（Windows/Linux/Android/iOS）

示例 1：图像处理（边缘检测+人脸识别）

import cv2
import matplotlib.pyplot as plt

# 读取图片
img = cv2.imread('input.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转灰度图

# Canny边缘检测
edges = cv2.Canny(gray, 100, 200)

# 人脸检测（Haar级联）
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, 1.1, 4)

# 标记人脸
for (x,y,w,h) in faces:
    cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)

# 显示结果
plt.figure(figsize=(12,4))
plt.subplot(131), plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)), plt.title('人脸检测')
plt.subplot(132), plt.imshow(gray, cmap='gray'), plt.title('灰度图')
plt.subplot(133), plt.imshow(edges, cmap='gray'), plt.title('边缘检测')
plt.show()

示例 2：实时视频处理（摄像头+物体跟踪）

import cv2

# 初始化摄像头
cap = cv2.VideoCapture(0)
tracker = cv2.TrackerCSRT_create()  # 创建跟踪器

# 第一帧选择ROI
ret, frame = cap.read()
bbox = cv2.selectROI("Tracking", frame, False)
tracker.init(frame, bbox)

while True:
    ret, frame = cap.read()
    if not ret: break
    
    # 更新跟踪器
    success, bbox = tracker.update(frame)
    if success:
        x,y,w,h = [int(i) for i in bbox]
        cv2.rectangle(frame, (x,y), (x+w,y+h), (0,255,0), 2)
    
    # 显示帧率
    fps = cap.get(cv2.CAP_PROP_FPS)
    cv2.putText(frame, f"FPS: {int(fps)}", (10,30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2)
    
    cv2.imshow("Tracking", frame)
    if cv2.waitKey(1) == 27:  # ESC退出
        break

cap.release()
cv2.destroyAllWindows()

关键功能：

TrackerCSRT_create()：高精度跟踪算法

selectROI()：交互式选择跟踪区域

CAP_PROP_FPS：获取实时帧率

工具类库

1. tqdm

tqdm（阿拉伯语 “taqadum” 的缩写，意为 “进展”）是 Python 的进度条工具库，核心功能包括：

实时进度可视化：在循环或迭代操作中显示进度条、剩余时间和速度。
低侵入性：只需封装现有迭代器，无需大幅修改代码
多功能支持：支持命令行、Jupyter Notebook、GUI 等环境
性能开销极低：进度更新频率自动优化，几乎不影响原程序速度

适用场景：数据处理、文件下载、模型训练、批量任务等需要长时间等待的操作

示例 1：基本循环进度条

from tqdm import tqdm
import time

# 在 range 循环中添加进度条
for i in tqdm(range(100), desc="处理进度"):
    time.sleep(0.02)  # 模拟耗时操作

# 输出效果：
# 处理进度: 100%|██████████| 100/100 [00:02<00:00, 49.99it/s]

关键参数：

desc：进度条前的描述文字

unit：单位（默认 “it” 即迭代次数）

colour：进度条颜色（如 'green'）

示例 2：文件下载与处理

import requests
from tqdm import tqdm

url = "https://example.com/bigfile.zip"
response = requests.get(url, stream=True)
total_size = int(response.headers.get('content-length', 0))

# 下载文件并显示进度
with open("bigfile.zip", "wb") as f:
    for chunk in tqdm(
        response.iter_content(1024),
        total=total_size,
        unit='B',
        unit_scale=True,
        desc="下载进度"
    ):
        f.write(chunk)

# 输出效果：
# 下载进度: 100%|██████████| 150M/150M [00:05<00:00, 30.1MB/s]

参数说明：

unit_scale：自动转换单位（B → KB → MB）

total：总大小（用于计算百分比）

2. Click

Click 是 Python 的命令行工具开发库，用于快速构建功能强大的 CLI（命令行界面）应用，核心功能包括：

简化参数解析：自动生成 --help 文档，支持选项/参数/子命令。
类型转换与验证：自动将输入参数转为 Python 类型（如 int/float/文件路径）。
彩色输出支持：内置 ANSI 颜色格式化。
可组合设计：支持嵌套命令和复杂参数结构。

特点：

比标准库 argparse 代码量减少 50%

被 Flask、Django 等知名项目用于管理命令

示例 1：基础命令（计算幂运算）

import click

@click.command()
@click.option('--base', type=int, help='底数', required=True)
@click.option('--exp', type=int, default=2, help='指数（默认2）')
def cli(base, exp):
    """计算 base 的 exp 次方"""
    result = base ** exp
    click.echo(f"结果: {click.style(str(result), fg='green')}")

if __name__ == '__main__':
    cli()

使用方式：

python demo.py --base 3 --exp 4
# 输出: 结果: 81 (绿色文字)

自动生成的帮助文档：

python demo.py --help

输出：

Usage: demo.py [OPTIONS]

  计算 base 的 exp 次方

Options:
  --base INTEGER  底数 [required]
  --exp INTEGER   指数（默认2）
  --help          Show this message and exit.

示例 2：文件处理工具（含子命令）

import click
from pathlib import Path

@click.group()
def cli():
    """文件管理工具"""
    pass

@cli.command()
@click.argument('path', type=click.Path(exists=True))
def info(path):
    """显示文件信息"""
    p = Path(path)
    click.echo(f"大小: {p.stat().st_size} 字节")
    click.echo(f"修改时间: {p.stat().st_mtime}")

@cli.command()
@click.argument('src', type=click.Path(exists=True))
@click.argument('dst', type=click.Path())
def copy(src, dst):
    """复制文件"""
    with open(src, 'rb') as f1, open(dst, 'wb') as f2:
        with click.progressbar(f1, label='复制进度') as bar:
            for chunk in bar:
                f2.write(chunk)
    click.secho("复制完成！", fg='bright_green')

if __name__ == '__main__':
    cli()

功能演示：

# 显示帮助
python file_tool.py --help

# 子命令用法
python file_tool.py info /path/to/file
python file_tool.py copy source.txt target.txt

交互效果：

复制进度 [####################################] 100%
复制完成！ (亮绿色文字)

3. Faker

Faker 是 Python 的假数据生成库，用于快速生成逼真的测试数据，核心功能包括：

多语言支持：支持中文、英文、日文等 20+ 语言地区的假数据。
丰富的数据类别：姓名/地址/公司/日期/电话号码/车牌号/虚拟信用卡等。
高度可定制：可自定义生成规则和数据结构。
测试友好：避免使用真实数据导致隐私问题。

适用场景：数据库填充、前端开发模拟数据、自动化测试、教学演示

示例 1：生成中文假数据

from faker import Faker

# 创建中文假数据生成器
fake = Faker('zh_CN')

# 生成5条虚拟用户信息
for _ in range(5):
    print(f"姓名: {fake.name()}")
    print(f"地址: {fake.address()}")
    print(f"手机号: {fake.phone_number()}")
    print(f"信用卡: {fake.credit_card_full()}")
    print("-" * 30)

输出示例：

姓名: 王静
地址: 广东省深圳市龙华区民治街道518号
手机号: 13559871234
信用卡: Visa, 4929 1212 1222 1432, 王静, 08/29, CVC: 123
------------------------------
姓名: 张伟
地址: 北京市海淀区中关村南大街5号
手机号: 18812345678
信用卡: Mastercard, 5100 3412 3456 7890, 张伟, 05/27, CVC: 456

示例 2：生成结构化测试数据（JSON格式）

import json
from faker import Faker

fake = Faker()

# 生成100条虚拟订单数据
orders = []
for _ in range(100):
    orders.append({
        "order_id": fake.uuid4(),
        "customer": fake.name(),
        "product": fake.word(ext_word_list=["手机", "笔记本", "耳机", "充电宝"]),
        "price": fake.pyfloat(left_digits=3, right_digits=2, positive=True),
        "date": fake.date_between(start_date="-1y").isoformat()
    })

# 保存为JSON文件
with open("test_orders.json", "w", encoding='utf-8') as f:
    json.dump(orders, f, ensure_ascii=False, indent=2)

print("已生成测试数据文件: test_orders.json")

生成的JSON片段：

[
  {
    "order_id": "5b2f4c7a-9d1e-4a3b-b5f6-7c8d9e0f1a2b",
    "customer": "李娜",
    "product": "耳机",
    "price": 456.99,
    "date": "2023-05-17"
  }
]

4. pytest

pytest 是 Python 的单元测试框架，核心功能包括：

自动化测试发现：自动查找 test_*.py 文件和 Test* 类
简洁断言语法：用 assert 直接验证结果（无需记忆 self.assertEqual 等方法）
丰富插件生态：支持覆盖率报告、并行测试、参数化测试等
Fixtures 依赖注入：复用测试资源（如数据库连接）

特点：

比标准库 unittest 代码量减少 50%

被 NumPy、pandas 等知名项目采用

示例 1：基础测试（函数测试）

被测代码 math_ops.py

def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为0")
    return a / b

测试代码 test_math.py

import pytest
from math_ops import add, divide

def test_add():
    assert add(2, 3) == 5  # 直接使用assert
    assert add(-1, 1) == 0

def test_divide():
    assert divide(6, 3) == 2.0
    with pytest.raises(ValueError, match="除数不能为0"):  # 验证异常
        divide(1, 0)

运行测试

pytest -v test_math.py

输出：

============================= test session starts =============================
test_math.py::test_add PASSED                                            [ 50%]
test_math.py::test_divide PASSED                                         [100%]
============================== 2 passed in 0.01s ==============================

示例 2：高级用法（Fixtures + 参数化）

被测代码 user.py

class User:
    def __init__(self, name):
        self.name = name
    
    def get_title(self):
        return f"User: {self.name}"

测试代码 test_user.py

import pytest

@pytest.fixture
def sample_user():
    """提供测试用的用户实例"""
    return User("Alice")

@pytest.mark.parametrize("name, expected", [
    ("Alice", "User: Alice"),  # 测试用例1
    ("Bob",   "User: Bob"),    # 测试用例2
    ("",      "User: "),       # 边界条件
])
def test_get_title(name, expected):
    assert User(name).get_title() == expected

def test_fixture_usage(sample_user):
    assert "Alice" in sample_user.get_title()

运行测试

pytest -v test_user.py

输出：

============================= test session starts =============================
test_user.py::test_get_title[Alice-User: Alice] PASSED                   [ 25%]
test_user.py::test_get_title[Bob-User: Bob] PASSED                       [ 50%]
test_user.py::test_get_title[-User: ] PASSED                             [ 75%]
test_user.py::test_fixture_usage PASSED                                  [100%]
============================== 4 passed in 0.02s ==============================

总结

依赖注入：复用测试资源（如数据库连接）

特点：

比标准库 unittest 代码量减少 50%

被 NumPy、pandas 等知名项目采用

示例 1：基础测试（函数测试）

被测代码 math_ops.py

def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为0")
    return a / b

测试代码 test_math.py

import pytest
from math_ops import add, divide

def test_add():
    assert add(2, 3) == 5  # 直接使用assert
    assert add(-1, 1) == 0

def test_divide():
    assert divide(6, 3) == 2.0
    with pytest.raises(ValueError, match="除数不能为0"):  # 验证异常
        divide(1, 0)

运行测试

pytest -v test_math.py

输出：

============================= test session starts =============================
test_math.py::test_add PASSED                                            [ 50%]
test_math.py::test_divide PASSED                                         [100%]
============================== 2 passed in 0.01s ==============================

示例 2：高级用法（Fixtures + 参数化）

被测代码 user.py

class User:
    def __init__(self, name):
        self.name = name
    
    def get_title(self):
        return f"User: {self.name}"

测试代码 test_user.py

import pytest

@pytest.fixture
def sample_user():
    """提供测试用的用户实例"""
    return User("Alice")

@pytest.mark.parametrize("name, expected", [
    ("Alice", "User: Alice"),  # 测试用例1
    ("Bob",   "User: Bob"),    # 测试用例2
    ("",      "User: "),       # 边界条件
])
def test_get_title(name, expected):
    assert User(name).get_title() == expected

def test_fixture_usage(sample_user):
    assert "Alice" in sample_user.get_title()

运行测试

pytest -v test_user.py

输出：

============================= test session starts =============================
test_user.py::test_get_title[Alice-User: Alice] PASSED                   [ 25%]
test_user.py::test_get_title[Bob-User: Bob] PASSED                       [ 50%]
test_user.py::test_get_title[-User: ] PASSED                             [ 75%]
test_user.py::test_fixture_usage PASSED                                  [100%]
============================== 4 passed in 0.02s ==============================