标准库概览

Python 标准库包含超过 200 个模块，覆盖操作系统接口、文本处理、数据结构、网络通信等常见需求。掌握这些模块能避免重复造轮子，也能让代码更简洁、更健壮。以下按功能分组介绍最常用的模块，每个模块附带可直接运行的示例。

操作系统接口：os 与 sys

os 模块提供与操作系统交互的函数，涵盖文件、目录、进程和环境变量。os.path 子模块处理路径拼接和查询，是跨平台开发的关键：

import os

print(os.getcwd())                    # 获取当前工作目录
os.chdir('/tmp')                      # 切换目录
print(os.path.join('data', '2024', 'log.txt'))  # 'data/2024/log.txt'（自动处理分隔符）
print(os.path.exists('log.txt'))      # 检查文件是否存在
print(os.path.getsize('log.txt'))     # 获取文件大小（字节），文件不存在则抛 OSError

sys 模块则与 Python 解释器本身交互，提供命令行参数、模块搜索路径和退出机制：

import sys

print(sys.argv)           # 命令行参数列表，argv[0] 是脚本名
sys.path.append('/custom/libs')  # 动态扩展模块搜索路径
sys.stderr.write('Error: file not found\n')  # 向标准错误输出
sys.exit(1)               # 以非零状态码终止程序，表示异常退出

注意 os.open() 与内置 open() 完全不同——前者是底层系统调用，返回文件描述符；后者返回文件对象。因此应避免 from os import *，以免意外替换内置函数。

数学与随机：math 与 random

math 模块封装了 C 标准库的数学函数，操作对象均为浮点数：

import math

print(math.pi)                    # 3.141592653589793
print(math.e)                     # 自然常数
print(math.log(1024, 2))          # 10.0，以 2 为底的对数
print(math.sqrt(-1))              # ValueError: math domain error
print(math.inf > 1e308)           # True，正无穷
print(math.nan == math.nan)       # False，NaN 的特性

random 模块生成伪随机数，适用于模拟和游戏，但不应用于密码学安全场景：

import random

random.seed(42)                   # 固定种子，结果可复现
print(random.choice(['A', 'B', 'C']))  # 随机选一个
print(random.sample(range(100), 5))    # 无放回抽样 5 个
print(random.uniform(1.0, 10.0))       # 均匀分布浮点数

data = [1, 2, 3, 4, 5]
random.shuffle(data)              # 原地打乱顺序
print(data)

日期与时间：datetime

datetime 模块提供 date、time、datetime 和 timedelta 类型，支持日期运算和格式化：

from datetime import date, datetime, timedelta, timezone

today = date.today()
print(today.strftime('%Y-%m-%d'))  # '2024-06-07'

birth = date(1990, 5, 15)
print((today - birth).days)        # 计算已活天数

now = datetime.now(timezone.utc)   # 带 UTC 时区的当前时间
print(now.isoformat())             # '2024-06-07T12:34:56.789012+00:00'

# 解析字符串
dt = datetime.strptime('2024-12-25 18:00', '%Y-%m-%d %H:%M')
print(dt + timedelta(hours=3))     # 加 3 小时

strftime 和 strptime 是互逆操作：前者将日期对象格式化为字符串，后者将字符串解析为日期对象。格式代码 %Y 表示四位年份，%m 表示月份，%d 表示日期。

文本模式匹配：re

re 模块提供正则表达式支持，用于复杂的字符串搜索和替换：

import re

text = 'Email: alice@example.com, bob@test.org'
# findall 返回所有匹配子串
print(re.findall(r'\b\w+@\w+\.\w+\b', text))

# search 返回第一个匹配对象，未找到返回 None
m = re.search(r'(\w+)@(\w+\.\w+)', text)
if m:
    print(m.group(0))   # 完整匹配
    print(m.group(1))   # 用户名
    print(m.group(2))   # 域名

# sub 做替换，\1 引用第一个捕获组
print(re.sub(r'(\w+)@(\w+\.\w+)', r'\1@[隐藏]', text))

# compile 预编译，适合同一模式多次使用
pattern = re.compile(r'\d+')
print(pattern.findall('Room 101, Floor 3'))  # ['101', '3']

默认情况下量词是贪婪的（匹配尽可能多的字符），在量词后加 ? 可变为非贪婪：

html = '<div>content</div>'
print(re.search(r'<.*>', html).group())    # '<div>content</div>' 贪婪
print(re.search(r'<.*?>', html).group())  # '<div>' 非贪婪

数据交换：json

json 模块在 Python 对象与 JSON 字符串之间转换，支持基本类型、列表和字典：

import json

data = {'name': 'Alice', 'age': 30, 'skills': ['Python', 'Go']}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)

# 从字符串解析
parsed = json.loads(json_str)
print(parsed['skills'][0])  # 'Python'

# 直接读写文件
with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False)

with open('data.json', 'r', encoding='utf-8') as f:
    loaded = json.load(f)

JSON 不支持 Python 的 datetime、set 和自定义对象。对于 datetime，通常先转换为 ISO 格式字符串再序列化；对于自定义对象，需要实现自定义编码器：

class Person:
    def __init__(self, name):
        self.name = name

# 默认序列化会抛 TypeError
try:
    json.dumps(Person('Alice'))
except TypeError as e:
    print(e)  # Object of type Person is not JSON serializable

高级容器：collections

collections 模块扩展了内置容器类型，解决常见数据结构需求：

from collections import Counter, defaultdict, deque, namedtuple

# Counter 自动统计元素出现次数
c = Counter('abracadabra')
print(c.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]

# defaultdict 为不存在的键提供默认值
d = defaultdict(list)
d['fruits'].append('apple')
d['fruits'].append('banana')
print(d['fruits'])       # ['apple', 'banana']
print(d['veggies'])      # []，不会抛 KeyError

# deque 双端队列，两端操作均为 O(1)
dq = deque(maxlen=3)
dq.append(1)
dq.append(2)
dq.appendleft(0)
print(dq)                # deque([0, 1, 2], maxlen=3)
dq.append(3)             # 超出 maxlen，最右侧的 2 被挤出
print(dq)                # deque([0, 1, 3], maxlen=3)

# namedtuple 创建带字段名的元组子类
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p.x, p.y)          # 11 22

迭代器工具：itertools

itertools 提供用于创建高效迭代器的函数，特别适合处理组合和排列问题：

import itertools

# permutations 排列
print(list(itertools.permutations('AB', 2)))
# [('A', 'B'), ('B', 'A')]

# combinations 组合
print(list(itertools.combinations([1, 2, 3, 4], 2)))
# [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

# cycle 无限循环
for i, val in enumerate(itertools.cycle('AB')):
    if i >= 5:
        break
    print(val, end=' ')  # A B A B A

# chain 拼接多个可迭代对象
print(list(itertools.chain([1, 2], [3, 4], [5])))  # [1, 2, 3, 4, 5]

# groupby 按连续相同元素分组（需先排序）
data = 'AAABBBCCAAA'
for k, g in itertools.groupby(data):
    print(k, len(list(g)))  # A 3, B 3, C 2, A 3

函数式工具：functools

functools 模块提供高阶函数和可调用对象操作：

from functools import lru_cache, partial, reduce

# lru_cache 缓存最近最多使用的结果，适合递归和重复计算
@lru_cache(maxsize=128)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(100))  # 瞬间完成，未缓存时递归深度极大
print(fib.cache_info())  # 查看命中次数和缓存大小

# partial 固定部分参数，创建新函数
basetwo = partial(int, base=2)
print(basetwo('1010'))  # 10

# reduce 累积计算
print(reduce(lambda x, y: x * y, [1, 2, 3, 4]))  # 24，即 1*2*3*4

lru_cache 要求被装饰函数的参数是可哈希的。如果传入列表等不可哈希对象，会抛出 TypeError。

类型提示：typing

Python 3.5+ 引入类型提示，typing 模块提供泛型类型和特殊类型标记，供静态分析工具（如 mypy）和 IDE 使用：

from typing import List, Dict, Optional, Union, Callable, TypeVar

# 基本容器类型
def process(items: List[int]) -> Dict[str, int]:
    return {str(i): i for i in items}

# Optional 表示可能为 None
def find_user(user_id: int) -> Optional[str]:
    if user_id > 0:
        return f"user_{user_id}"
    return None

# Union 表示多种可能类型
def parse(value: Union[str, int]) -> int:
    if isinstance(value, str):
        return int(value)
    return value

# Callable 描述函数签名
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

# TypeVar 定义泛型参数
T = TypeVar('T')
def first(items: List[T]) -> Optional[T]:
    return items[0] if items else None

类型提示在运行时被忽略，不会影响程序行为，但能帮助捕获逻辑错误并改善代码可读性。

总结

标准库的设计遵循"自带电池"理念：os 和 sys 处理系统级操作；math 和 random 满足数值计算；datetime 管理时间；re 处理文本模式；json 负责数据交换；collections、itertools 和 functools 扩展了数据结构与算法工具箱；typing 则让大型项目的类型约束成为可能。熟悉这些模块的适用范围和边界行为，是写出高效 Python 代码的基础。