w wyl123ly 的博客
MD

Python-06-常用标准库

80 KB 2026.10.11 原文件

Python-06-常用标准库

一句话概括

Python 的哲学之一是「内置电池(batteries included)」:装好解释器就带着一套足够写完整个工具链的库。会用标准库的人,代码短、依赖少、踩坑少。本篇按「数据处理 → 时间与文本 → 系统交互 → 工程化」四条线,把最常用的十几个模块讲透,每个都配可运行示例。


一、是什么

1.1 标准库的范围与地位

标准库(Standard Library)是随 CPython 一起分发、不需要 pip install 的模块集合。它在官方文档里按功能分成几十个章节,本笔记只覆盖日常开发中出现频率最高的十几类。

三个层次要分清:

层次例子是否需要安装稳定性
内置函数与类型len、print、list、dict无(解释器内置)极稳定
标准库json、pathlib、logging无(随解释器分发)稳定,弃用有过渡期(PEP 387)
第三方包requests、numpy、django需要 pip install各自为政

重点

「标准库有的功能,优先用标准库」。理由有三:零依赖(部署、审计、安全扫描都轻松)、文档与行为稳定(弃用要经过 PEP 387 的漫长流程)、生态共识(所有人都会用)。只有标准库明显不足时(HTTP 客户端、数据处理、Web 框架)才引入第三方。

1.2 本篇的模块地图

分类模块本篇覆盖
数据结构collections、itertools、functools✅ 全部
时间与文本datetime、re、json✅ 全部
数学与随机math、statistics、random、secrets✅ 全部
系统交互os、sys、subprocess、pathlib✅ 本节
工程化logging、argparse、hashlib、timeit✅ 全部
不在本篇pathlib、csv、异常机制见 [[Python-05-异常与文件IO]]

二、为什么这样设计

2.1 「内置电池」的来龙去脉

PEP 20(The Zen of Python)里有一句常被引用的话:

Simple is better than complex. / 简洁优于复杂。

内置电池哲学是这句话在工程层面的落地:如果「读 JSON 文件」需要先选一个第三方库、再处理版本冲突,「简洁」就无从谈起。标准库的设计目标不是「最好」,而是「足够好 + 永远在」。

维度标准库第三方库
依赖负担0需要管理版本、传递依赖
API 优雅度通常偏底层、偏啰嗦往往更贴合场景
性能一般(纯 C 的部分很快)常见专门的性能优化(如 orjson)
功能边界只做通用能力可以做得深、做得专
安全责任官方团队维护你需要跟踪 CVE
升级风险低(有弃用周期)高(大版本可能破坏兼容)

2.2 为什么标准库「够用」但「不奢华」

以 HTTP 为例:标准库有 urllib.request,能发请求,但 API 难用、不支持连接池、不自动处理 JSON。requests 因此成为事实标准。这不是标准库设计失败,而是分工:

  • 标准库负责提供基础且稳定的能力(socket、SSL、HTTP 协议编解码);
  • 第三方负责在此之上做符合人体工程学的封装。

所以在选型时的判断顺序是:先看标准库有没有(够用就用)→ 不够用再看官方推荐的第三方 → 都不行才自己写。


三、核心内容

3.1 collections:专用容器

collections 提供五个高频容器类型。

类型一句话作用底层实现典型场景复杂度
Counter计数dict 子类词频、投票统计计数 ,取前 用
defaultdict缺键时自动给默认值dict 子类分组、邻接表
deque双端队列分块双向链表队列、滑动窗口、BFS两端 ,中间
namedtuple有字段名的轻量元组tuple 子类数据库行、坐标与元组同
OrderedDict记住插入顺序的字典哈希表 + 双向链表需要 move_to_end/popitem(last=False)
ChainMap多层字典叠加视图字典列表配置覆盖(默认值 + 环境变量)查找
from collections import Counter, defaultdict, deque, namedtuple, OrderedDict, ChainMap

# ---------- Counter:计数与「前 N 名」 ----------
words = "the quick brown fox jumps over the lazy dog the fox".split()
c = Counter(words)
print(c.most_common(2))          # [('the', 3), ('fox', 2)]
print(c["not-exist"])            # 0 —— 缺键返回 0 而不是 KeyError
c.update(["the", "cat"])         # 增量更新
print(c["the"], c["cat"])        # 4 1
# 集合运算:适合「比较两段文本的用词差异」
c2 = Counter("the cat sat".split())
print(c - c2)                    # 只保留计数为正的项
print(c & c2)                    # 取每个键的最小计数(交集)
print(c | c2)                    # 取每个键的最大计数(并集)


# ---------- defaultdict:分组不用先判空 ----------
rows = [
    ("数学", "李雷", 95),
    ("数学", "韩梅梅", 88),
    ("物理", "李雷", 79),
]
by_subject = defaultdict(list)
for subject, name, score in rows:
    by_subject[subject].append((name, score))   # 第一次访问自动创建 list
print(dict(by_subject))

# 计数也可以用 defaultdict(int),但 Counter 语义更明确
counts = defaultdict(int)
for subject, _, _ in rows:
    counts[subject] += 1
print(dict(counts))

# 更省内存的写法(Python 3.8+):__missing__ 只在缺键时调用
# 注意 defaultdict 的工厂函数不要用 lambda 闭包捕获循环变量,否则会出现「所有键共用一个对象」


# ---------- deque:两端 O(1) ----------
# maxlen 是「固定容量」:一旦填满,从一端插入就会把**另一端**的元素挤出去。
q = deque([1, 2, 3], maxlen=4)
q.append(4)                       # 右进,还没满,不挤任何元素 → [1, 2, 3, 4]
q.appendleft(0)                   # 左进,此时长度为 5 超限 → 挤掉最右的 4 → [0, 1, 2, 3]
print(q)                          # deque([0, 1, 2, 3], maxlen=4)
q.append(5)                       # 右进,超限 → 挤掉最左的 0 → [1, 2, 3, 5]
print(q)                          # deque([1, 2, 3, 5], maxlen=4)
# 记住挤出的方向:append 挤左端、appendleft 挤右端,即「挤出与插入相反的那一端」。
# maxlen 让 deque 天然适合「最近 N 条记录」这类环形缓冲,不需要手写取模逻辑。

# 滑动窗口求最大值:deque 存下标,保持单调递减
def max_sliding_window(nums: list[int], k: int) -> list[int]:
    """时间复杂度 O(n):每个下标最多入队出队一次。"""
    dq: deque[int] = deque()
    result = []
    for i, v in enumerate(nums):
        while dq and nums[dq[-1]] <= v:      # 队尾比当前值小就永远不可能是最大值
            dq.pop()
        dq.append(i)
        if dq[0] <= i - k:                   # 队首超出窗口
            dq.popleft()
        if i >= k - 1:
            result.append(nums[dq[0]])
    return result


print(max_sliding_window([1, 3, -1, -3, 5, 3, 6, 7], 3))   # [3, 3, 5, 5, 6, 7]


# ---------- namedtuple:有名字的元组 ----------
Point = namedtuple("Point", ["x", "y"], defaults=[0, 0])
p = Point(1, 2)
print(p, p.x, p[0])               # Point(x=1, y=2) 1 1
print(p._replace(x=10))           # 生成新对象,原对象不变(元组不可变)
print(Point._fields)              # ('x', 'y')
print(Point(3))                   # Point(x=3, y=0) —— 使用了 defaults


# ---------- OrderedDict:顺序有语义的字典 ----------
od = OrderedDict.fromkeys("abc", 0)
od.move_to_end("a")               # 把 a 移到末尾
print(list(od))                   # ['b', 'c', 'a']
print(od.popitem(last=False))     # ('b', 0) —— 从头部弹出,实现 FIFO 缓存

# 与普通 dict 的区别:3.7+ 普通 dict 也保持插入顺序,
# 但 OrderedDict 额外提供 move_to_end 与 popitem(last=...),
# 且 == 比较是「顺序敏感」的:
print(OrderedDict(a=1, b=2) == OrderedDict(b=2, a=1))   # False
print({"a": 1, "b": 2} == {"b": 2, "a": 1})             # True


# ---------- ChainMap:配置分层覆盖 ----------
defaults = {"host": "127.0.0.1", "port": 8000, "debug": False}
env = {"port": 9000}
cli = {"debug": True}
config = ChainMap(cli, env, defaults)     # 左边优先级最高
print(config["port"], config["host"], config["debug"])   # 9000 127.0.0.1 True

defaultdict 的三个坑

1. 访问不存在的键会创建它:if key in dd 是安全的,但 dd[key] 会留下空值。用 dd.get(key) 检查存在性。

2. 工厂函数必须可调用:defaultdict(list) 对,defaultdict([]) 错(会抛 TypeError: first argument must be callable or None)。

3. copy() 是浅拷贝,且新对象与原对象共享工厂函数;深层结构要 copy.deepcopy。

3.2 itertools:惰性迭代工具

itertools 的所有函数都返回迭代器(iterator),惰性求值:不消耗内存、可以处理无限序列、可以用 for 或 next() 驱动。

函数作用结果数量时间复杂度空间复杂度
chain(*its)串联多个可迭代对象
groupby(it, key)相邻元素分组组数
product(a, b)笛卡尔积
permutations(it, r)排列
combinations(it, r)组合
combinations_with_replacement可重复组合同上
islice(it, start, stop, step)惰性切片
count(start, step)无限等差序列—
cycle(it)无限循环—
repeat(x, n)重复—
accumulate(it, op)累积运算(前缀和/前缀积)
zip_longest(*its)按最长的对齐
takewhile / dropwhile按条件取/丢前缀不定
tee(it, n)把一个迭代器复制成 份——
import itertools as it
from itertools import chain, groupby, product, permutations, combinations, islice

# ---------- chain:把多个来源当成一个来遍历 ----------
a, b = [1, 2], [3, 4]
print(list(chain(a, b)))                          # [1, 2, 3, 4]
print(list(chain.from_iterable([[1, 2], [3], [4, 5]])))   # [1, 2, 3, 4, 5] —— 展平一层
# chain 比 a + b 的优势:惰性、不需要创建中间列表,可以串联无限序列


# ---------- groupby:只合并「相邻」的相同键 ----------
data = [("水果", "苹果"), ("水果", "香蕉"), ("蔬菜", "白菜"), ("水果", "橘子")]
for key, group in groupby(data, key=lambda x: x[0]):
    # 关键:group 是迭代器,一旦开始遍历下一组就失效,必须立即消费
    print(key, [item[1] for item in group])
# 水果 ['苹果', '香蕉'] / 蔬菜 ['白菜'] / 水果 ['橘子'] —— 注意有两个「水果」!

# 要按全局分组必须先排序(这是最常见的 groupby 误用)
sorted_data = sorted(data, key=lambda x: x[0])
for key, group in groupby(sorted_data, key=lambda x: x[0]):
    print(key, [item[1] for item in group])


# ---------- product / permutations / combinations ----------
print(list(product("AB", [1, 2])))              # 笛卡尔积,共 4 项
print(list(product("AB", repeat=2)))            # AA AB BA BB —— 相当于自己和自己做积
print(list(permutations("ABC", 2)))             # 6 项,顺序不同算不同
print(list(combinations("ABC", 2)))             # 3 项,顺序无关
print(list(it.combinations_with_replacement("AB", 2)))   # AA AB BB

# 实战:用 product 生成立方体网格坐标,比三重循环更紧凑
grid = list(product(range(2), repeat=3))
print(len(grid), grid[:2])                      # 8 [(0,0,0), (0,0,1)]


# ---------- islice:惰性切片(切片语法 greedy,islice 不 greedy)----------
def naturals():
    """无限自然数序列:如果是列表,这段代码会 OOM。"""
    n = 0
    while True:
        yield n
        n += 1


print(list(islice(naturals(), 5)))              # [0, 1, 2, 3, 4]
print(list(islice(naturals(), 10, 15)))         # [10, 11, 12, 13, 14]
print(list(islice(naturals(), 0, 10, 3)))       # [0, 3, 6, 9]

# 读一个巨大文件的前 5 行:不需要读全文
# with open("huge.log", encoding="utf-8") as f:
#     first5 = list(islice(f, 5))


# ---------- accumulate:前缀和 ----------
from itertools import accumulate
import operator

nums = [1, 2, 3, 4]
print(list(accumulate(nums)))                                   # [1, 3, 6, 10]
print(list(accumulate(nums, operator.mul)))                     # [1, 2, 6, 24]
print(list(accumulate(nums, initial=0)))                        # [0, 1, 3, 6, 10]
print(min(accumulate(nums)))                                    # 1
# 用前缀和 + 差分可以在 O(1) 内回答「任意区间和」

groupby 最容易踩的坑

1. 它只合并相邻元素,不排序就会得到重复的组。需要全局分组时先 sorted(),或直接用 defaultdict(list)。

2. group 迭代器在一次外层迭代结束后就失效。写成 groups = [g for _, g in groupby(...)] 再使用,会得到一堆空迭代器。必须在循环内立即消费。

3. sorted + groupby 是 + ,而 defaultdict 分组是 。数据量大且不需要有序时用后者。

3.3 functools:函数工具

工具作用关键点典型场景
lru_cache(maxsize)记忆化(memoization)参数必须可哈希;缓存无过期时间递归、纯计算、IO 去重
cache等价于 lru_cache(maxsize=None)3.9+ 提供;无淘汰结果集有限的纯函数
cached_property只算一次的属性需要实例有 __dict__昂贵的派生数据
partial固定部分参数生成新可调用对象回调、map 的辅助函数
reduce累积3.x 起移到这里(不再内置)折叠操作
wraps保留被装饰函数的元数据写装饰器必用所有装饰器
total_ordering补齐比较方法只需 __eq__ + 一个 __lt__自定义可排序类
singledispatch按第一个参数类型分派多态函数替代一堆 isinstance 分支
import time
from functools import lru_cache, cache, partial, reduce, wraps, total_ordering, singledispatch
import operator

# ---------- lru_cache:把指数级递归降成线性 ----------
def fib_slow(n: int) -> int:
    return n if n < 2 else fib_slow(n - 1) + fib_slow(n - 2)


@lru_cache(maxsize=None)          # 等价于 @cache(Python 3.9+)
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)


print(fib(200))
print(fib.cache_info())           # CacheInfo(hits=198, misses=201, maxsize=None, currsize=201)

# 复杂度对比:
# fib_slow(n) 的调用次数满足 T(n) = T(n-1) + T(n-2) + O(1),即 T(n) = O(phi^n),phi ≈ 1.618
# fib(n) 加了缓存后每个 n 只算一次,时间 O(n)、空间 O(n)


# ---------- 自建缓存 vs 标准库 ----------
_manual: dict[int, int] = {}


def fib_manual(n: int) -> int:
    """手写缓存:能看清 lru_cache 到底做了什么。"""
    if n in _manual:
        return _manual[n]
    result = n if n < 2 else fib_manual(n - 1) + fib_manual(n - 2)
    _manual[n] = result
    return result


# ---------- 坑:参数必须可哈希 ----------
@lru_cache(maxsize=128)
def bad(items: list) -> int:
    return sum(items)


try:
    bad([1, 2, 3])
except TypeError as e:
    print("报错:", e)             # unhashable type: 'list'
# 修法:调用方传 tuple,或在内部转换


# ---------- partial:固定部分参数 ----------
def power(base: float, exponent: float) -> float:
    return base ** exponent


square = partial(power, exponent=2)      # 关键字固定,避免位置参数错位
cube = partial(power, exponent=3)
print(square(5), cube(3))                # 25 27

# 实战:sorted 的 key 需要单参数函数
records = ["2026-10-11", "2026-01-05", "2026-12-31"]
print(sorted(records, key=partial(str.split, sep="-")))   # 按 [年, 月, 日] 列表比较


# ---------- reduce:折叠 ----------
print(reduce(operator.add, [1, 2, 3, 4]))            # 10
print(reduce(operator.mul, [1, 2, 3, 4], 1))         # 24
print(reduce(lambda acc, x: acc if acc > x else x, [3, 1, 4, 1, 5]))   # 5 —— 手写 max
# 注意:reduce 不带初值时,空序列会抛 TypeError


# ---------- wraps:装饰器必用 ----------
def timed(func):
    @wraps(func)                  # 不加 wraps,函数名会变成 "wrapper",__doc__ 也会丢
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        try:
            return func(*args, **kwargs)
        finally:
            # 用 finally 保证函数抛异常时也能记录耗时
            print(f"{func.__name__} 耗时 {(time.perf_counter() - t0) * 1000:.2f} ms")
    return wrapper


@timed
def work(n: int) -> int:
    """一个耗时函数。"""
    return sum(i * i for i in range(n))


work(100_000)
print(work.__name__, work.__doc__)     # work 一个耗时函数。


# ---------- total_ordering:只写两个方法就有全部比较 ----------
@total_ordering
class Version:
    def __init__(self, text: str):
        self.parts = tuple(int(x) for x in text.split("."))

    def __eq__(self, other):
        return isinstance(other, Version) and self.parts == other.parts

    def __lt__(self, other):
        return self.parts < other.parts


print(Version("1.10.0") > Version("1.9.3"))    # True —— 元组比较,逐位比


# ---------- singledispatch:按类型分派 ----------
@singledispatch
def render(value):
    """默认实现:只调用 str()。"""
    return str(value)


@render.register
def _(value: list) -> str:
    # 注册后,第一个参数是 list 时走这里
    return "[" + ", ".join(render(v) for v in value) + "]"


@render.register
def _(value: dict) -> str:
    return "{" + ", ".join(f"{k}: {render(v)}" for k, v in value.items()) + "}"


print(render([1, {"a": 2}, [3]]))

3.4 datetime:时间与时区

四个核心类型:

类型含义有无时区典型用途
date日期(年-月-日)无生日、账单日
time时间(时:分:秒.微秒)无营业时间
datetime日期 + 时间可选绝大多数场景
timedelta时间差—运算
timezone / zoneinfo.ZoneInfo时区信息—跨时区转换

朴素(naive)与感知(aware):不带 tzinfo 的 datetime 叫 naive,它不知道自己属于哪个时区;带 tzinfo 的叫 aware。

from datetime import datetime, date, time, timedelta, timezone
import time as time_module

# ---------- 时间戳:自 1970-01-01 00:00:00 UTC 起的秒数(Unix epoch)----------
now = datetime.now()                       # naive,本地时间
now_utc = datetime.now(timezone.utc)       # aware,UTC
print(now, now_utc)

ts = now.timestamp()                       # naive 会被当作「本地时间」解释
print(ts)
# fromtimestamp 是 timestamp 的逆运算,同样按本地时区解释
print(datetime.fromtimestamp(ts))

# 用 time 模块拿时间戳更直接
print(time_module.time())

# ---------- strftime(格式化输出)与 strptime(解析输入)----------
dt = datetime(2026, 10, 11, 14, 30, 5, 123456, tzinfo=timezone.utc)
print(dt.strftime("%Y-%m-%d %H:%M:%S"))            # 2026-10-11 14:30:05
print(dt.strftime("%Y年%m月%d日 %A"))               # %A 是本地化的星期名
print(dt.isoformat())                              # 2026-10-11T14:30:05.123456+00:00

parsed = datetime.strptime("2026-10-11 14:30:05", "%Y-%m-%d %H:%M:%S")
print(parsed, parsed.year, parsed.month, parsed.day, parsed.weekday())

# fromisoformat:解析 ISO 8601,比 strptime 快且不用记格式串(3.11+ 支持更多格式)
print(datetime.fromisoformat("2026-10-11T14:30:05+00:00"))

常用格式码:

码含义例
%Y四位年2026
%m两位月10
%d两位日11
%H %M %S24 小时制时/分/秒14:30:05
%f微秒(6 位)123456
%zUTC 偏移+0800
%a %A缩写/全称星期名Sun / Sunday
%b %B缩写/全称月份名Oct / October
%j一年中的第几天284
%W %U周数—
%%字面百分号%
# ---------- timedelta 运算 ----------
d1 = date(2026, 10, 11)
d2 = date(2026, 1, 1)
delta = d1 - d2
print(delta, delta.days)                 # 283 days, 0:00:00  283

print(d1 + timedelta(days=30))            # 2026-11-10
print(d1 - timedelta(weeks=2))            # 2026-09-27
print(datetime(2026, 10, 11, 23, 59) + timedelta(minutes=2))   # 自动进位到次日

# timedelta 内部只保存 days/seconds/microseconds 三个整数
td = timedelta(hours=2, minutes=30)
print(td.total_seconds() / 3600)          # 2.5
print(td.days, td.seconds)                # 0 9000 —— 注意 2 小时被存进 seconds

# 时间差转成「人类可读」
def humanize(td: timedelta) -> str:
    total = int(td.total_seconds())
    days, rem = divmod(total, 86400)
    hours, rem = divmod(rem, 3600)
    minutes = rem // 60
    return f"{days} 天 {hours} 小时 {minutes} 分"


print(humanize(delta))

# ---------- 两个日期之间相差多少个工作日 ----------
def workdays(start: date, end: date) -> int:
    """O(天数)。数据量大时用公式计算,不要逐天遍历。"""
    count, cur = 0, start
    while cur < end:
        if cur.weekday() < 5:             # 0=周一 … 4=周五
            count += 1
        cur += timedelta(days=1)
    return count


print(workdays(date(2026, 10, 1), date(2026, 10, 11)))

时区陷阱——这是 datetime 最容易出错的部分,务必理解:

from datetime import datetime, timezone
from zoneinfo import ZoneInfo          # Python 3.9+ 标准库

utc = datetime(2026, 10, 11, 12, 0, tzinfo=timezone.utc)
bj = utc.astimezone(ZoneInfo("Asia/Shanghai"))
ny = utc.astimezone(ZoneInfo("America/New_York"))
print(bj)          # 2026-10-11 20:00:00+08:00
print(ny)          # 2026-10-11 08:00:00-04:00(夏令时 EDT)
print(bj == ny)    # True —— aware datetime 比较的是绝对时刻,不是显示值

# ❌ 陷阱 1:naive 与 aware 不能比较,会抛 TypeError
try:
    datetime(2026, 10, 11) < datetime.now(timezone.utc)
except TypeError as e:
    print("比较失败:", e)      # can't compare offset-naive and offset-aware datetimes

# ❌ 陷阱 2:用 utcnow() 得到的是 naive 的 UTC 时间,容易被误当本地时间
naive_utc = datetime.utcnow()              # 3.12 起已弃用
correct = datetime.now(timezone.utc)       # ✅ 推荐写法

# ❌ 陷阱 3:时区偏移会因为夏令时(DST)变化
# 固定偏移 timezone(timedelta(hours=-5)) 在夏令时期间会算错,
# 必须用按地区定义的 ZoneInfo(它内含 DST 规则)
for month in (1, 7):
    t = datetime(2026, month, 15, 12, 0, tzinfo=ZoneInfo("America/New_York"))
    # utcoffset() 返回的是「相对于 UTC 的偏移」,不是时差;
    # 1 月是 -05:00(EST),7 月是 -04:00(EDT),因为美国实行夏令时
    print(month, t.utcoffset())            # 1 -1 day, 19:00:00   7 -1 day, 20:00:00
    # timedelta 把负数表示成「days 为负 + seconds 为正」,所以 -5 小时显示为 -1 day, 19:00:00
    # 想看得直观就做一次转换:
    hours = t.utcoffset().total_seconds() / 3600
    print(f"  → UTC{hours:+.0f}")          # → UTC-5    → UTC-4

# ❌ 陷阱 4:时区切换时会出现不存在或重复的本地时间
# 2026-03-08 02:30 在美国东部「不存在」(时钟从 02:00 跳到 03:00)
# 处理本地时间的正确策略:存储用 UTC,展示时再转本地

时间处理的四条铁律

1. 存 UTC,显示时转本地。数据库统一存 UTC aware datetime,前端按用户时区渲染。

2. 不要用 datetime.utcnow()(3.12 起弃用,因为它返回 naive 对象,容易被当成 UTC 之外的时区)。用 datetime.now(timezone.utc)。

3. 不要用 time.time() 之外的时间戳做运算,跨时区、跨夏令时的算术一律用 aware datetime + timedelta。

4. 不要自己实现时区数据库。用 zoneinfo(依赖系统的 IANA tzdata)或 tzdata 包。

3.5 re:正则表达式

正则是描述字符串模式的小型语言。Python 的 re 模块底层用 C 实现(回溯引擎),写法简洁但对复杂模式可能出现指数级回溯。

常用元字符表:

语法含义例
.任意字符(默认不含换行)a.c 匹配 abc、a c
^ / $行首 / 行尾(MULTILINE 下为每行)^abc
\d / \D数字 / 非数字\d+ 匹配 123
\w / \W单词字符(字母数字下划线,Unicode 感知)/ 非单词字符\w+
\s / \S空白 / 非空白\s+
[abc] / [^abc]字符集合 / 补集[0-9a-fA-F]
[a-z]范围—
* + ?0+ / 1+ / 0 或 1(贪婪)a*
{m,n}m 到 n 次\d{2,4}
*? +? ?? {m,n}?非贪婪版本<.+?>
( )捕获分组(\d{4})-(\d{2})
(?: )非捕获分组(?:ab)+
(?P<name> )命名分组(?P<year>\d{4})
`\`或`cat\dog`
\b / \B单词边界 / 非单词边界\bcat\b
(?= ) / (?! )前向肯定 / 否定断言\d+(?=px)
(?<= ) / (?<! )后向肯定 / 否定断言(必须定长)(?<=\$)\d+
\1 \2反向引用(\w)\1 匹配 aa

贪婪与非贪婪:默认贪婪(尽可能多匹配),加 ? 变非贪婪(尽可能少匹配)。

import re

html = "<b>粗体</b> 和 <i>斜体</i>"

# 贪婪:.* 一路吃到「最后一个 >」,整个串被当成 1 个匹配
print(re.findall(r"<.*>", html))
# ['<b>粗体</b> 和 <i>斜体</i>']   ← 只 1 项,标签边界全部丢失

# 非贪婪:.+? 在第一个能匹配的位置就停,得到 4 个独立标签
print(re.findall(r"<.+?>", html))
# ['<b>', '</b>', '<i>', '</i>']

# 需要「配对开闭标签」时,用反向引用 \1 保证前后标签名一致
print(re.findall(r"<([a-z]+)>.*?</\1>", html))   # ['b', 'i'] —— 只返回捕获组内容
print(re.findall(r"<([a-z]+)>.*?</\1>", html, re.S))   # re.S 让 . 也能匹配换行

# 经典例子:非贪婪在「取引号内容」上的作用
text = '他说"你好"然后说"再见"'
print(re.findall(r'"(.*?)"', text))        # ['你好', '再见'] ✅
print(re.findall(r'"(.*)"', text))         # ['你好"然后说"再见'] ❌ 贪婪吃太宽

compile 的性能意义:re 模块内部维护一个缓存(默认 512 条),所以 re.match(pattern, s) 在循环里不会每次重新编译。但缓存有上限、有查表开销,在热点循环里预先 compile 更快、意图也更清晰。

import re
import timeit

pattern = r"\d{4}-\d{2}-\d{2}"
texts = ["2026-10-11"] * 1000

# 预编译一次,循环里复用
compiled = re.compile(pattern)

t1 = timeit.timeit(lambda: [re.match(pattern, t) for t in texts], number=200)
t2 = timeit.timeit(lambda: [compiled.match(t) for t in texts], number=200)
print(f"未预编译 {t1:.4f}s  预编译 {t2:.4f}s  提速 {t1 / t2:.2f}x")

分组与命名分组:

import re

log = "2026-10-11 14:30:05 [ERROR] 数据库连接超时"

# 位置分组
m = re.search(r"(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})", log)
if m:
    # group(0) 是整个匹配,group(1..n) 是各组
    print(m.group(0))
    print(m.groups())                       # 所有分组的元组
    print(m.group(1), m.group(2))           # 2026 10
    print(m.span(1))                        # (0, 4) 第 1 组在原串中的位置

# 命名分组:可读性远好于数字下标,重构时不易错
pat = re.compile(
    r"(?P<date>\d{4}-\d{2}-\d{2})\s+"
    r"(?P<time>\d{2}:\d{2}:\d{2})\s+"
    r"\[(?P\w+)\]\s+"
    r"(?P<msg>.+)"
)
m = pat.search(log)
print(m.groupdict())            # {'date': ..., 'time': ..., 'level': 'ERROR', 'msg': ...}

# 命名分组在替换串里用 \g<name> 引用
print(pat.sub(r"\g<level> @ \g<date> \g<time> :: \g<msg>", log))

# 常用 API 一览
print(re.findall(r"\d+", "a1b22c333"))          # ['1', '22', '333'] 有分组时返回分组元组列表
print(re.split(r"[,;]\s*", "a, b; c"))          # ['a', 'b', 'c']
print(re.sub(r"\s+", " ", "a   b\t\nc"))        # a b c
print(re.sub(r"\d+", lambda m: str(int(m.group()) * 2), "a1b2"))   # 替换可以是函数
print(re.subn(r"\d", "#", "a1b2"))              # ('a#b#', 2) 返回替换次数

# re.finditer:需要位置或其他信息时用迭代器(findall 只返回内容)
for m in re.finditer(r"\d+", "a1b22c333"):
    print(m.group(), m.start(), m.end())

# 预定义字符集的补充:\A \Z(串首串尾,不受 MULTILINE 影响)
函数返回无匹配时何时用
re.match(p, s)Match 或 NoneNone只从开头匹配
re.fullmatch(p, s)Match 或 NoneNone要求整串匹配(校验格式首选)
re.search(p, s)Match 或 NoneNone任意位置首次出现
re.findall(p, s)list[]要所有匹配的内容
re.finditer(p, s)迭代器空要所有匹配并需要位置信息
re.split(p, s)list—按模式切分
re.sub(p, r, s)str原串替换
标志作用
re.IGNORECASE / re.I忽略大小写
re.MULTILINE / re.M^/$ 匹配每行首尾
re.DOTALL / re.S. 也匹配换行
re.VERBOSE / re.X允许空白与 # 注释,长模式必备
re.ASCII / re.A\w \d \s 只匹配 ASCII(默认是 Unicode 感知)
# VERBOSE 模式:把复杂正则写成可读的多行形式
email_pat = re.compile(r"""
    ^                       # 串首
    [\w.+-]+                # 用户名部分
    @
    (?:[\w-]+\.)+           # 域名(至少一个点,非捕获分组)
    [A-Za-z]{2,}            # 顶级域
    $                       # 串尾
""", re.VERBOSE)

print(bool(email_pat.match("user.name+tag@example.co.uk")))    # True
print(bool(email_pat.match("not-an-email")))                   # False

灾难性回溯(Catastrophic Backtracking)

嵌套量词(如 (a+)+$)在匹配失败时会产生指数级的回溯,一个几十字符的输入就能让 CPU 跑满。这是 ReDoS(Regular Expression Denial of Service)攻击的原理。

```python

import re, time

bad = re.compile(r"(a+)+b")

s = "a" * 28

t0 = time.perf_counter()

bad.search(s) # 不要在生产环境跑长输入

print(f"{time.perf_counter() - t0:.2f}s") # 输入每多 1 个 a,耗时约翻倍

```

防御手段:避免嵌套量词;用 (a+) 代替 (a+)+;对不可信输入限制字符串长度;使用线性时间的引擎(第三方 regex 模块的 POSIX 模式,或干脆手写解析器)。

3.6 json:数据交换格式

json 的完整类型映射、ensure_ascii=False、自定义编码见 Python-05-异常与文件IO 的 3.14 节。这里补充工程实践要点。

import json
from datetime import datetime, date

# ---------- 缩进与排序:让 diff 干净 ----------
data = {"b": 2, "a": 1}
print(json.dumps(data, sort_keys=True, indent=2))
# sort_keys=True 保证同一份数据每次输出一致,方便版本控制与测试断言

# ---------- 中文不转义 ----------
print(json.dumps({"名字": "李雷"}))                          # {"\u540d\u5b57": "\u674e\u96f7"}
print(json.dumps({"名字": "李雷"}, ensure_ascii=False))       # {"名字": "李雷"}

# ---------- 用 JSONEncoder 子类做类型适配 ----------
class AppEncoder(json.JSONEncoder):
    def default(self, o):
        # 只有遇到「不认识」的对象才会调用这里
        if isinstance(o, (datetime, date)):
            return o.isoformat()
        if isinstance(o, set):
            return sorted(o)
        if hasattr(o, "to_dict"):
            return o.to_dict()
        return super().default(o)          # 交给父类抛 TypeError,保留标准行为


payload = {"时间": datetime(2026, 10, 11, 14, 30), "标签": {"b", "a"}}
print(json.dumps(payload, cls=AppEncoder, ensure_ascii=False))


# ---------- 大文件流式读取:JSON Lines ----------
# 一行一个 JSON 对象(.jsonl)比一个大 JSON 数组更适合日志:
# 可以逐行读取(内存恒定)、可以追加写入、单行损坏不影响其他行
def iter_jsonl(path: str):
    with open(path, encoding="utf-8") as f:
        for lineno, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue
            try:
                yield json.loads(line)
            except json.JSONDecodeError as e:
                # 日志格式场景:跳过坏行并留下痕迹,比整体失败更实用
                print(f"跳过第 {lineno} 行:{e.msg}")


for record in iter_jsonl("events.jsonl"):
    print(record)
参数作用建议
ensure_ascii中文是否转成 \uXXXX存文件用 False,走 HTTP 无所谓
indent缩进空格数人读用 2;机器读、网络传输用 None(体积小很多)
sort_keys按键排序需要 diff / 哈希去重 / 测试断言时用 True
separators分隔符紧凑输出用 (",", ":")
default / cls自定义编码遇到 TypeError 时用
object_hook自定义解码需要还原成对象时用
allow_nan是否允许 NaN/Infinity对外接口设 False(非标准 JSON)
parse_float浮点解析函数需要 Decimal 精确小数时用

JSON 不能碰的三类数据

1. 循环引用:直接抛 ValueError: Circular reference detected。

2. dict 的非字符串键:json.dumps({1: "a"}) 会输出 {"1": "a"},读回来键变成字符串 "1",往返不幂等。

3. 浮点精度:0.1 + 0.2 序列化后是 0.30000000000000004;金融数据请用 Decimal + 字符串传输(parse_float=decimal.Decimal)。

3.7 random 与 secrets:随机数

核心区别:random 是伪随机(可预测),secrets 是密码学安全随机。

维度randomsecrets
算法Mersenne Twister(梅森旋转)操作系统 CSPRNG(getrandom//dev/urandom)
可复现✅ 设了种子就完全确定❌ 不可复现
速度快略慢
周期不适用
适用模拟、抽样、洗牌、游戏、测试数据密码、Token、验证码、盐值、会话 ID
禁用场景绝不可用于安全用途—
import random
import secrets
import string

# ---------- random:伪随机与种子 ----------
random.seed(42)                      # 固定种子 → 结果可复现,这是单元测试的关键
print(random.random())               # [0.0, 1.0) 的浮点
print(random.randint(1, 6))          # 闭区间 [1, 6],模拟掷骰子
print(random.randrange(0, 10, 2))    # 半开区间 + 步长 → 偶数
print(random.uniform(1, 2))          # 均匀分布浮点
print(random.gauss(0, 1))            # 正态分布(均值、标准差)
print(random.choice(["红", "绿", "蓝"]))
print(random.choices(["红", "绿", "蓝"], weights=[5, 3, 2], k=5))   # 有放回、可按权重
print(random.sample(range(100), 5))  # 无放回抽样,等价于「洗牌后取前 k」O(n)
cards = list(range(10))
random.shuffle(cards)                # 就地洗牌(Fisher-Yates,O(n))
print(cards)

# 更现代的写法:独立的 Random 实例,避免影响全局状态
rng = random.Random(42)              # 局部随机源,适合并发/并行场景
print(rng.randint(1, 100))
# 多线程下应各自持有 Random 实例:全局 random 虽然线程安全,但会互相影响序列


# ---------- secrets:安全场景 ----------
# Token:适合 URL、会话 ID(URL 安全字符集,无歧义)
token = secrets.token_urlsafe(32)
# token_urlsafe(n) 取 n 个随机「字节」(默认 32),再按 base64url 编码。
# 32 字节 → ceil(32/3)*4 = 44 个 base64 字符,去掉可能的 1 个 '=' 填充,通常得到 43 字符。
# 所以长度是「大约 43」,取决于字节数,不要把它当成固定值。
print(token, len(token))

# 十六进制 / 字节串
print(secrets.token_hex(16))
print(secrets.token_bytes(16))

# 安全随机选择与整数
print(secrets.randbelow(100))        # [0, 100)
print(secrets.choice("abcdef"))

# 人类可读的验证码/初始密码:注意避免易混淆字符
ALPHABET = string.ascii_letters + string.digits


def gen_password(n: int = 12) -> str:
    """用 secrets 生成密码:绝不能用 random。"""
    return "".join(secrets.choice(ALPHABET) for _ in range(n))


print(gen_password())

# 常量时间比较:防止时序攻击(timing attack)
import hmac
a, b = b"secret-token", b"secret-token"
print(hmac.compare_digest(a, b))     # ✅ 用时序安全的方式比较
# 不要用 a == b 比较密钥/Token:短路比较会泄漏前缀信息

用 random 生成密码是安全事故

梅森旋转算法的内部状态可以通过观察624 个连续输出完全还原。也就是说,攻击者只要拿到足够多的历史随机结果,就能预测后续所有「随机」值。任何与安全相关的随机性——密码重置 Token、会话 ID、验证码、加密盐、抽奖——必须用 secrets(或 os.urandom)。

3.8 math 与 statistics

import math
import statistics

# ---------- math:浮点数学(返回 float)----------
print(math.sqrt(2), math.isqrt(10))       # 1.414... 3 —— isqrt 返回整数平方根,大数专用
print(math.floor(2.7), math.ceil(2.1), round(2.5))   # 2 3 2(round 是「银行家舍入」!)
print(math.gcd(12, 18), math.lcm(4, 6))   # 6 12
print(math.factorial(5), math.comb(5, 2), math.perm(5, 2))   # 120 10 20
print(math.hypot(3, 4))                   # 5.0 —— 比 sqrt(x*x+y*y) 更稳定,不会溢出
print(math.log(8, 2), math.log2(8), math.log10(1000), math.exp(1))   # 3.0 3.0 3.0 2.718...
print(math.pi, math.e, math.tau, math.inf, math.nan)
print(math.isclose(0.1 + 0.2, 0.3))       # True —— 浮点比较必须用 isclose,不要用 ==
print(math.degrees(math.pi), math.radians(180))    # 180.0 3.14159...

# ---------- 浮点比较与求和的正确姿势 ----------
print(0.1 + 0.2 == 0.3)                   # False!二进制浮点无法精确表示 0.1/0.2
print(repr(0.1 + 0.2))                    # 0.30000000000000004
print(math.isclose(0.1 + 0.2, 0.3))       # True —— 浮点相等判断一律用 isclose
print(math.fsum([0.1] * 10))              # 1.0 —— 精确求和(内部用部分和补偿)
print(sum([0.1] * 10))                    # 1.0(Python 3.12 起 sum 也用了补偿求和)

# 注意:Python 3.12 起内置 sum() 改用 Neumaier 补偿求和,精度已大幅提升,
# 在多数输入上结果与 math.fsum 相同。二者的可靠差别在「保证」而非「日常结果」:
#   - math.fsum 保证返回「正确舍入」的和,是精度层面的权威选择;
#   - sum 更快,且能直接处理 Decimal / Fraction 等类型。
# 结论:一般代码用 sum 即可;对精度有硬性要求(如累加大量浮点测量值)时用 math.fsum。
# 涉及金额时两者都不该用——请用 decimal.Decimal。

# ---------- statistics:统计量(返回 float,对精度更友好)----------
data = [2, 4, 4, 4, 5, 5, 7, 9]
print(statistics.mean(data))              # 4.375
print(statistics.median(data))            # 4.5
print(statistics.mode(data))              # 4
print(statistics.pstdev(data), statistics.stdev(data))   # 总体 / 样本标准差
print(statistics.variance(data))          # 样本方差
print(statistics.quantiles(data, n=4))    # 四分位数

# 标准差公式(总体):sigma = sqrt( (1/N) * sum (x_i - mu)^2 )
# 样本用 N-1(贝塞尔校正),这就是 stdev 与 pstdev 的区别

# 协方差与相关系数
xs = [1, 2, 3, 4, 5]
ys = [2, 4, 6, 8, 11]
print(statistics.covariance(xs, ys), statistics.correlation(xs, ys))

# 加权平均
print(statistics.fmean([1, 2, 3]))        # 2.0 —— fmean 比 mean 快且精度更好
print(statistics.geometric_mean([1, 4, 16]))

round() 是银行家舍入,不是四舍五入

round(0.5) 得到 0,round(1.5) 得到 2,round(2.5) 得到 2。原因是「向最近偶数舍入」能避免大量数据累积偏差。需要严格的四舍五入用 decimal:

```python

from decimal import Decimal, ROUND_HALF_UP

print(Decimal("2.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP)) # 3

```

涉及金额一律用 decimal.Decimal 而不是 float: 在二进制浮点下是必然的。

3.9 os / sys / subprocess

sys:解释器本身的信息与控制

import sys

print(sys.version)                # 解释器版本字符串
print(sys.version_info[:3])       # 元组,便于比较:if sys.version_info >= (3, 10):
print(sys.platform)               # 'win32' / 'linux' / 'darwin'
print(sys.executable)             # 当前解释器路径(子进程应复用它,而不是硬编码 "python")
print(sys.argv)                   # 命令行参数列表,argv[0] 是脚本名
print(sys.path[:2])               # 模块搜索路径
print(sys.maxsize)                # 最大整数(决定 int 是否溢出,Python int 无溢出)
print(sys.getrecursionlimit())    # 递归深度限制

sys.stderr.write("这行写到标准错误\n")     # 日志应写 stderr,避免污染 stdout 管道

# sys.exit 会抛 SystemExit——这就是它继承 BaseException 而非 Exception 的原因:
# 一个粗心的 except Exception 不该把「正常退出」当成错误吞掉。
# 注意:SystemExit 一旦抛出,后面的语句不会执行,所以放在示例最后一行。
sys.exit(0)                       # 0 表示成功,非 0 表示失败

os:与操作系统交互

import os

print(os.name)                    # 'nt' / 'posix'
print(os.getcwd())                # 当前工作目录
os.makedirs("a/b/c", exist_ok=True)   # 递归建目录,幂等
print(os.listdir(".")[:3])
print(os.environ.get("PATH", "")[:50])    # 读环境变量,用 .get 避免 KeyError
os.environ["MY_VAR"] = "1"        # 设置(只影响当前进程及其子进程)
print(os.cpu_count())             # CPU 核数,决定进程池大小的常用依据
print(os.urandom(4).hex())        # 操作系统级随机字节
print(os.getpid(), os.getppid())  # 进程号 / 父进程号
任务推荐(现代)旧写法
路径操作pathlib.Pathos.path
遍历目录树Path.rglob / os.walkos.listdir + 递归
建目录Path.mkdir(parents=True, exist_ok=True)os.makedirs
删除目录树shutil.rmtree—
环境变量os.environ.get(k, default)os.getenv

subprocess:执行外部命令

有两种方式,必须理解区别:

import subprocess
import shlex
import sys

# ---------- 方式一:传列表(推荐)----------
# 参数按列表传递,shell 不参与解析 → 天然免疫命令注入
result = subprocess.run(
    [sys.executable, "-c", "print('hello from child')"],   # 用 sys.executable 而非 "python"
    capture_output=True,      # 捕获 stdout/stderr(不再打印到控制台)
    text=True,                # 以文本(str)而不是 bytes 返回
    encoding="utf-8",         # 显式指定编码,避免中文乱码
    timeout=10,               # 超时保护:防止子进程挂死拖垮主程序
    check=False,              # check=True 时非零退出码会抛 CalledProcessError
)
print(result.returncode)      # 0 表示成功
print(result.stdout.strip())
print(result.stderr)

# 用 check=True 让失败直接抛异常(多数场景比手动判断 returncode 干净)
try:
    subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"],
                   capture_output=True, text=True, check=True, timeout=5)
except FileNotFoundError:
    print("git 未安装")
except subprocess.CalledProcessError as e:
    print("命令失败:", e.returncode, e.stderr)
except subprocess.TimeoutExpired:
    print("命令超时")


# ---------- 方式二:shell=True(有安全风险)----------
# shell=True 会把字符串交给系统的 shell 解析,因此支持管道、重定向、通配符
out = subprocess.run("echo a && echo b", shell=True, capture_output=True,
                     text=True, timeout=5)
print(out.stdout.strip())

# ❌ 危险:用户输入直接拼进 shell 字符串 → 命令注入
# user_input = "file.txt; rm -rf /"
# subprocess.run(f"cat {user_input}", shell=True)      # 灾难

# ✅ 如果确实需要 shell 特性,用 shlex.quote 转义每个参数
user_input = "file with spaces.txt"
safe_cmd = f"cat {shlex.quote(user_input)}"
print("将要执行:", safe_cmd)
# 更推荐:能不用 shell 就不用。管道可以用 Python 实现:
#   第一个命令的 stdout=PIPE,作为第二个命令的 stdin=
p1 = subprocess.run(["echo", "hello"], capture_output=True, text=True, timeout=5)
p2 = subprocess.run(["tr", "a-z", "A-Z"], input=p1.stdout,
                    capture_output=True, text=True, timeout=5)
print(p2.stdout.strip())      # HELLO
对比项subprocess.run([...])subprocess.run("...", shell=True)
参数解析由 Python 直接 exec由系统 shell 解析
命令注入风险❌ 无✅ 有
支持管道/重定向/通配符需自己实现原生支持
跨平台一致性高低(&&、引号规则各平台不同)
Windows 上的内建命令无法直接调用 dir、copy可以
推荐度✅ 默认选择⚠️ 仅在必要时,且必须 shlex.quote

安全清单

- 用户输入永远不要直接拼进 shell=True 的字符串。

- 需要 shell 特性时用 shlex.quote() 转义,或改用列表参数 + Python 自己实现管道。

- shell=True 在 cwd= 或 env= 受污染时同样危险(如 PATH 被篡改)。

- 子进程一定要设 timeout,否则一个挂死的命令会让服务永久阻塞。

3.10 logging:日志

为什么不用 print:

维度printlogging
级别无DEBUG/INFO/WARNING/ERROR/CRITICAL
输出目标只能 stdout文件、stderr、网络、syslog 多路同时
开关要改代码改配置/环境变量即可
时间戳与位置需手写格式串自动带
性能总是执行级别不满足时跳过格式化
多线程安全不保证内置锁保护
生产可用性不可可(轮转、结构化、接入监控)
库内使用禁止✅ 加 NullHandler 静默

五个级别(数值越大越严重):

级别数值何时用
DEBUG10诊断细节:变量值、分支走向、SQL 原文
INFO20正常里程碑:服务启动、任务完成、用户登录
WARNING30可继续但需注意:重试成功、配置缺失用默认值、弃用提醒
ERROR40功能失败但程序还能跑:请求处理失败、写文件失败
CRITICAL50程序无法继续:数据库连不上、关键依赖缺失
import logging
import sys

# ---------- basicConfig:脚本/小工具的最简配置 ----------
# 只在 root logger 没有 handler 时才生效;重复调用默认被忽略
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    stream=sys.stderr,           # 日志写 stderr,stdout 留给程序输出(便于管道处理)
    force=True,                  # 3.8+:强制重配,便于在测试/Jupyter 里反复运行
)

logging.debug("这条不会显示,因为级别是 INFO")
logging.info("服务已启动")
logging.warning("配置文件缺少 timeout,使用默认值 30")
logging.error("写入缓存失败")
logging.critical("磁盘空间不足,无法继续")


# ---------- 库代码:用模块级 logger + NullHandler ----------
# 库永远不要调用 basicConfig,也不要往 root 上加 handler——那是应用的责任
logger = logging.getLogger(__name__)
logger.addHandler(logging.NullHandler())      # 没人配置时不产生 "No handlers" 警告

# 使用 %s 惰性格式化:级别不够时不会真的拼接字符串
name, count = "用户", 42
logger.debug("调试信息 %s %d", name, count)     # ✅ 惰性
logger.debug(f"调试信息 {name} {count}")        # ❌ f-string 会立即求值,白白浪费


# ---------- 生产配置:handler + formatter ----------
import logging.handlers
from pathlib import Path

def setup_logging(log_dir: Path = Path("logs")) -> logging.Logger:
    """工程化配置:控制台精简 + 文件详细 + 自动轮转。"""
    log_dir.mkdir(parents=True, exist_ok=True)
    log = logging.getLogger("myapp")
    log.setLevel(logging.DEBUG)
    log.propagate = False          # 不再向 root 冒泡,避免重复打印

    if log.handlers:               # 幂等:重复调用不会叠加 handler
        return log

    console = logging.StreamHandler(sys.stderr)
    console.setLevel(logging.INFO)
    console.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))

    # 按大小轮转:单文件 1 MB,保留 5 个备份,避免磁盘被日志撑爆
    rotating = logging.handlers.RotatingFileHandler(
        log_dir / "app.log", maxBytes=1_000_000, backupCount=5, encoding="utf-8"
    )
    rotating.setLevel(logging.DEBUG)
    rotating.setFormatter(logging.Formatter(
        "%(asctime)s | %(levelname)-8s | %(name)s:%(lineno)d | %(message)s"
    ))

    log.addHandler(console)
    log.addHandler(rotating)
    return log


app_log = setup_logging()
app_log.info("配置完成")
app_log.debug("这条只进文件")


# ---------- 异常日志:exc_info 会记录完整回溯 ----------
try:
    1 / 0
except ZeroDivisionError:
    app_log.error("计算出错", exc_info=True)      # 等价于 app_log.exception("计算出错")

常用 format 字段:

字段含义
%(asctime)s时间(配合 datefmt)
%(levelname)s级别名
%(name)slogger 名(通常就是模块名)
%(message)s日志内容
%(pathname)s / %(filename)s文件路径 / 文件名
%(lineno)d行号
%(funcName)s函数名
%(process)d / %(threadName)s进程号 / 线程名

日志的三条实践经验

1. 库用 logging.getLogger(__name__),只加 NullHandler,把配置权留给应用。

2. 应用在入口处配置一次,用 dictConfig 或 fileConfig 从配置文件读取,方便区分环境。

3. 不要在循环里打高频日志。要么降级到 DEBUG,要么做采样/聚合,否则日志本身就是性能瓶颈(尤其是同步写文件 + fsync)。

3.11 argparse:命令行参数

import argparse
import sys


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="mytool",
        description="演示 argparse 的常用能力。",
        epilog="示例:mytool data.csv -n 10 --verbose",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,  # 自动显示默认值
    )

    # 位置参数(必填)
    parser.add_argument("input", type=str, help="输入文件路径")

    # 可选参数:--output / -o 两个名字指向同一个参数
    parser.add_argument("-o", "--output", default="out.txt", help="输出路径")

    # type 自动转换;choices 做取值校验;metavar 美化帮助信息里的占位符
    parser.add_argument("-n", "--count", type=int, default=5, choices=range(1, 101),
                        metavar="{1..100}", help="处理条数")

    # action="store_true":出现即 True,不出现为 False
    parser.add_argument("-v", "--verbose", action="store_true", help="输出详细信息")

    # action="count":可重复叠加,-vv 得到 2
    parser.add_argument("--debug-level", action="count", default=0)

    # action="append":可多次出现,收集成列表
    parser.add_argument("--tag", action="append", default=[], help="可重复指定标签")

    # 互斥组:两个选项不能同时出现
    group = parser.add_mutually_exclusive_group()
    group.add_argument("--json", action="store_true", help="以 JSON 输出")
    group.add_argument("--csv", action="store_true", help="以 CSV 输出")

    # 版本信息:--version 出现即刻打印并退出
    parser.add_argument("--version", action="version", version="%(prog)s 1.0.0")
    return parser


def main(argv: list[str] | None = None) -> int:
    # 传 argv 便于单元测试:main(["--count", "3", "x.txt"])
    args = build_parser().parse_args(argv)

    if args.verbose:
        print(f"参数:{vars(args)}")     # vars() 把 Namespace 转成 dict,便于调试

    print(f"input={args.input} output={args.output} count={args.count}")
    if args.tag:
        print("标签:", args.tag)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

运行效果:

$ python mytool.py -h
usage: mytool [-h] [-o OUTPUT] [-n {1..100}] [-v] [--debug-level] [--tag TAG]
              [--json | --csv] [--version]
              input

演示 argparse 的常用能力。

positional arguments:
  input                 输入文件路径

options:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        输出路径 (default: out.txt)
  ...
需求写法
必填位置参数add_argument("name")
可选参数(带长短名)add_argument("-o", "--output")
类型转换type=int / type=float / type=Path
限定取值choices=[...] 或 choices=range(...)
布尔开关action="store_true" / "store_false"
计数action="count"
收集多次action="append"
互斥add_mutually_exclusive_group()
子命令(git commit 风格)add_subparsers(dest="cmd")
从文件读参数fromfile_prefix_chars="@"

需要更复杂的 CLI 时

argparse 适合中小型工具。如果需要彩色输出、自动生成 shell 补全、嵌套子命令、类型驱动的参数定义,社区常用 click 或 typer(第三方)。以官方最新文档为准:https://docs.python.org/3/library/argparse.html

3.12 hashlib:哈希与校验

哈希函数把任意长度的输入映射成固定长度的摘要:

三条性质决定了它的用途:

  1. 确定性:同样的输入永远得到同样的输出(可用于校验、去重、缓存键)。
  2. 抗原像性:从 反推 在计算上不可行(可用于存密码——但要加盐 + 慢哈希)。
  3. 抗碰撞性:找到 且 在计算上不可行(可用于签名、去重)。
import hashlib
import hmac

# ---------- 基本用法 ----------
data = "你好,世界".encode("utf-8")     # 哈希只接受 bytes
print(hashlib.sha256(data).hexdigest())
print(hashlib.md5(data).hexdigest())    # ⚠️ MD5 已不安全,只用于非安全的校验
print(hashlib.sha3_256(data).hexdigest())
print(hashlib.blake2b(data).hexdigest())   # 快且安全,适合通用校验

# digest() 返回 bytes,hexdigest() 返回十六进制字符串

# ---------- 算法可用性查询 ----------
print(sorted(hashlib.algorithms_available)[:5])
print("sha256" in hashlib.algorithms_guaranteed)   # True,跨平台一定可用

# ---------- 增量更新:适合大文件,内存恒定 ----------
def file_sha256(path: str, chunk_size: int = 1 << 20) -> str:
    """分块读取计算哈希:1 MB 一块,内存占用与文件大小无关。"""
    h = hashlib.sha256()
    with open(path, "rb") as f:          # 二进制模式,避免换行符被转换
        while chunk := f.read(chunk_size):
            h.update(chunk)
    return h.hexdigest()


print(file_sha256("data.bin"))

# ---------- HMAC:带密钥的哈希,用于消息认证 ----------
key = b"shared-secret"
msg = b"transfer 100 CNY"
sig = hmac.new(key, msg, hashlib.sha256).hexdigest()
print(sig)

# 验证:用 compare_digest 而不是 ==,防止时序攻击
expected = hmac.new(key, msg, hashlib.sha256).hexdigest()
print(hmac.compare_digest(sig, expected))       # True

# ---------- 密码存储:绝不能用 sha256 直接存 ----------
# 原因:GPU 每秒可算数十亿次 sha256,弱密码会被彩虹表/暴力破解
# 正确做法:慢哈希 + 随机盐,迭代次数可调
import secrets


def hash_password(password: str, iterations: int = 600_000) -> str:
    """PBKDF2-HMAC-SHA256:加盐 + 大量迭代。

    生产环境建议直接用标准库的 hashlib.scrypt(需要 OpenSSL 1.1+)
    或第三方 argon2-cffi(当前密码哈希的推荐算法)。"""
    salt = secrets.token_bytes(16)          # 每个用户独立随机盐
    dk = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations)
    return f"pbkdf2_sha256${iterations}${salt.hex()}${dk.hex()}"


def verify_password(password: str, stored: str) -> bool:
    try:
        algo, iter_s, salt_hex, dk_hex = stored.split("$")
        if algo != "pbkdf2_sha256":
            return False
        dk = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"),
                                 bytes.fromhex(salt_hex), int(iter_s))
        return hmac.compare_digest(dk.hex(), dk_hex)
    except (ValueError, TypeError):
        return False                        # 格式错误一律视为校验失败,不泄漏原因


stored = hash_password("my-secret-pw")
print(verify_password("my-secret-pw", stored))   # True
print(verify_password("wrong-pw", stored))       # False
算法摘要长度安全状态用途
md5128 bit❌ 已被攻破(碰撞可在秒级构造)仅非安全校验(如去重、缓存键)
sha1160 bit❌ 已不推荐(SHAttered 攻击)遗留系统兼容
sha256 / sha512256 / 512 bit✅ 安全通用校验、签名、HMAC
sha3_256256 bit✅ 安全与 SHA-2 结构不同,作为备选
blake2b / blake2s可变✅ 安全性能敏感场景
pbkdf2_hmac / scrypt可变✅ 用于密码密码存储专用(慢哈希)

三个哈希相关的安全事故

1. 用 MD5/SHA1 存密码:碰撞攻击 + GPU 暴力破解,等于明文泄露。

2. 不加盐:同一密码得到同一哈希,彩虹表可批量反查;加盐还让「一次破解多个用户」失效。

3. 用 == 比较哈希/Token:Python 的字符串比较是短路的,攻击者可以通过响应时间差逐字节猜出正确值。用 hmac.compare_digest。

3.13 timeit:性能测量

timeit 通过多次重复取最小值来抵消系统噪声,比手写 time.time() 可靠得多。

import timeit

# ---------- 方式一:timeit.timeit(stmt, setup, number) ----------
t = timeit.timeit("'-'.join(str(n) for n in range(100))", number=10_000)
print(f"生成器 + join:{t:.4f}s")

t2 = timeit.timeit("'-'.join(map(str, range(100)))", number=10_000)
print(f"map + join:   {t2:.4f}s")
print(f"map 版本快 {t / t2:.2f}x")     # map 通常更快,因为没有 Python 层循环开销

# ---------- 方式二:repeat,取最小值更稳定 ----------
results = timeit.repeat("sum(range(1000))", number=1000, repeat=5)
print([f"{r:.4f}" for r in results])
print("最小值:", f"{min(results):.4f}s")     # 最小值最接近「真实最快速度」

# ---------- 方式三:命令行,适合比较整段脚本 ----------
# python -m timeit -s "import random" "random.random()"

# ---------- 方式四:Timer 类,复用 setup ----------
timer = timeit.Timer(
    stmt="d[k]",                          # 被测语句
    setup="d = {i: i for i in range(1000)}; k = 500",   # 只执行一次的准备代码
)
print(f"字典查找:{timer.timeit(number=1_000_000) / 1_000_000 * 1e9:.1f} ns/次")
对比项timeittime.perf_counter() 手写
抵消噪声✅ 多次重复❌ 单次测量波动大
关闭垃圾回收✅ 默认关闭❌ 需要自己 gc.disable()
微秒级测量✅ 适合容易被调度噪声淹没
适合微基准测试(microbenchmark)整段业务流程计时

微基准测试的三个陷阱

1. 测量结果不代表真实场景:CPU 缓存、数据规模、并发、IO 都会改变结论。微基准只用来比较同一尺度下的两种写法。

2. CPython 版本差异很大:3.11 引入 specializing adaptive interpreter 后,很多循环代码快了 20%–60%。跨版本比较毫无意义。

3. timeit 默认关闭 GC,如果你的真实代码会被 GC 打断,测出来的速度会偏乐观。用 timeit.Timer(...).timeit() 时注意 gc 已是 disabled 状态。

优化前先用 cProfile 找到真正的热点,不要凭直觉优化——90% 的时间往往花在 10% 的代码上。

3.14 模块选择速查表

需求首选备选 / 替代
计数、词频collections.Counterdict + get
分组collections.defaultdict(list)itertools.groupby(需先排序)
队列 / BFScollections.dequequeue.Queue(多线程)
固定字段的记录collections.namedtupledataclasses.dataclass
惰性迭代、笛卡尔积itertools手写生成器
记忆化functools.lru_cache手写 dict
时间戳 → 字符串datetime.strftimef-string 格式化
字符串解析restr.split(简单场景更快更清楚)
解析 JSONjsonorjson(性能)、pydantic(校验)
随机数(非安全)random—
随机数(安全)secretsos.urandom
数学函数mathnumpy(数组)
统计量statisticsnumpy / pandas
执行外部命令subprocess.run([...])shlex + shell=True(慎用)
日志logging结构化日志第三方库
命令行解析argparseclick / typer
哈希校验hashlib.sha256blake2b
密码存储hashlib.scryptargon2-cffi
性能测量timeitcProfile(找热点)

四、怎么用

一个端到端的小工具:扫描目录下的日志文件,按级别统计并输出 JSON 报告。它把本篇十来个模块串在一起。

"""日志分析小工具:综合演示常用标准库的协作。

用法:
    python logstat.py <目录> --top 5 --json
"""
from __future__ import annotations

import argparse
import json
import logging
import re
import statistics
import sys
from collections import Counter, defaultdict
from datetime import datetime
from functools import lru_cache
from itertools import islice
from pathlib import Path

logger = logging.getLogger("logstat")

# 用命名分组 + VERBOSE,让正则自解释;预编译避免循环里重复查缓存
LINE_RE = re.compile(r"""
    ^(?P<ts>\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})   # 时间戳
    \s+\[(?P[A-Z]+)\]\s+                        # 级别
    (?P<msg>.*)$                                       # 消息
""", re.VERBOSE)


@lru_cache(maxsize=4096)
def parse_ts(text: str) -> datetime | None:
    """时间戳解析是热点函数,用 lru_cache 避免重复解析同一字符串。"""
    try:
        return datetime.strptime(text, "%Y-%m-%d %H:%M:%S")
    except ValueError:
        logger.debug("无法解析时间戳:%r", text)
        return None


def iter_lines(path: Path, max_lines: int | None = None):
    """按行读取,内存恒定;max_lines 用于快速预览大文件。"""
    try:
        with open(path, encoding="utf-8", errors="replace") as f:
            yield from (islice(f, max_lines) if max_lines else f)
    except OSError as e:
        # 单个文件失败不应中断整批扫描
        logger.warning("跳过 %s:%s", path, e)


def analyze(root: Path, top: int, max_lines: int | None) -> dict:
    levels: Counter[str] = Counter()
    per_hour: defaultdict[str, int] = defaultdict(int)
    per_file: dict[str, int] = {}
    latencies: list[float] = []
    bad_lines = 0

    for path in sorted(root.rglob("*.log")):
        count = 0
        for line in iter_lines(path, max_lines):
            m = LINE_RE.match(line.rstrip("\n"))
            if not m:
                bad_lines += 1
                continue
            level = m.group("level")
            levels[level] += 1
            ts = parse_ts(m.group("ts"))
            if ts:
                per_hour[ts.strftime("%Y-%m-%d %H")] += 1
            # 从消息里提取形如 "耗时 12.3ms" 的数字
            if lm := re.search(r"耗时\s+([\d.]+)ms", m.group("msg")):
                latencies.append(float(lm.group(1)))
            count += 1
        per_file[path.name] = count

    report = {
        "扫描目录": str(root),
        "文件数": len(per_file),
        "总行数": sum(per_file.values()),
        "无法解析行数": bad_lines,
        "各文件行数": per_file,
        "级别分布": dict(levels.most_common()),
        "最繁忙时段": per_hour.most_common(top),
    }
    if latencies:
        report["耗时统计(ms)"] = {
            "样本数": len(latencies),
            "平均": round(statistics.fmean(latencies), 2),
            "中位数": statistics.median(latencies),
            "P95": round(statistics.quantiles(latencies, n=20)[18], 2),
            "最大": max(latencies),
        }
    return report


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="统计日志文件中的级别与耗时分布")
    p.add_argument("root", type=Path, help="要扫描的目录")
    p.add_argument("--top", type=int, default=5, help="最繁忙时段显示条数")
    p.add_argument("--max-lines", type=int, default=None,
                   help="每个文件最多读取的行数(大文件预览用)")
    p.add_argument("--json", action="store_true", help="以 JSON 输出")
    p.add_argument("--verbose", action="store_true", help="打印调试日志")
    return p


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    # 日志配置放在 main 里:import 该模块不应产生副作用
    logging.basicConfig(
        level=logging.DEBUG if args.verbose else logging.WARNING,
        format="%(levelname)s %(name)s: %(message)s",
        stream=sys.stderr,
    )

    if not args.root.is_dir():
        logger.error("不是目录:%s", args.root)
        return 2

    report = analyze(args.root, args.top, args.max_lines)

    if args.json:
        print(json.dumps(report, ensure_ascii=False, indent=2))
    else:
        for key, value in report.items():
            print(f"{key}: {value}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

各模块在其中的分工:

模块用在哪里为什么这么选
argparsebuild_parser零依赖的 CLI,自动生成 -h
pathlibroot.rglob("*.log")面向对象路径,递归匹配
itertools.isliceiter_lines预览前 N 行不读全文
re(预编译 + 命名分组)LINE_RE循环里复用编译结果,分组名可读
functools.lru_cacheparse_ts同格式时间戳重复出现,避免重复解析
collections.Counterlevels计数 + most_common
collections.defaultdictper_hour分组不必判空
statistics耗时统计分位数、中位数、fmean,比手写准
datetime时间戳解析与分桶strptime + strftime
json--json 输出ensure_ascii=False 保留中文
logging全流程警告进 stderr,--verbose 打开 DEBUG
sys.stderr日志流stdout 留给数据,便于管道

五、注意事项与常见坑

坑 1:datetime.utcnow() 与 naive datetime

datetime.utcnow() 返回的是 naive 对象,它「碰巧」是 UTC 时间,但没有任何时区标记。一旦和 aware 对象比较就抛 TypeError,或者被误认为本地时间算出 8 小时偏差。3.12 起已弃用,一律用 datetime.now(timezone.utc)。

坑 2:re.match 与 re.search 混淆

re.match 只从串首匹配,re.search 才是「任意位置」。校验用户输入「整串是否符合格式」应该用 re.fullmatch,否则 "123abc" 能通过 re.match(r"\d+", "123abc")。

坑 3:random 用于安全用途

见 3.7 节。密码、Token、验证码、抽奖、加密盐——全部改用 secrets。这是审计中最常见的严重问题之一。

坑 4:json.dumps 默认转义中文

默认 ensure_ascii=True 会把 "中文" 写成 "\u4e2d\u6587"。写文件给人看时要加 ensure_ascii=False,否则配置文件全是乱码般的转义序列。

坑 5:logging 重复输出

```python

logging.basicConfig() # 给 root 加了 handler

logger = logging.getLogger(__name__)

logger.addHandler(logging.StreamHandler()) # 又加一个 → 每条日志打印两次

```

原因:日志沿 logger 层级向上冒泡到 root,root 也有 handler。修法:库只加 NullHandler;应用层统一配置;或用 logger.propagate = False。

坑 6:subprocess 不设 timeout

子进程挂死时,主程序会永久阻塞。每一个 subprocess.run 都要有 timeout,并捕获 TimeoutExpired。

坑 7:deque 与 list 混用

list.pop(0) 是 (要移动所有元素),在队列场景下会退化成 。队列必须用 deque。

坑 8:lru_cache 用在有副作用或不可哈希参数的函数上

- 参数必须可哈希(list、dict、set 都不行);

- 有副作用(写文件、发请求)的函数加缓存会跳过副作用;

- 缓存永不自动过期,含时间戳参数的函数会无限增长(用 maxsize 限制,或自己控制 cache_clear());

- 被缓存的函数不要返回可变对象——调用方改了它,缓存里也变了(应返回副本或不可变对象)。

坑 9:argparse 的 type=bool 不工作

```python

parser.add_argument("--flag", type=bool) # ❌ 任何非空字符串都是 True

```

bool("False") 是 True。必须用 action="store_true" / "store_false"。

实践建议

- 写脚本:argparse + logging + pathlib + main() -> int 是最小可用骨架。

- 处理数据:先想清楚「要不要全部读进内存」,能流式就流式(itertools、生成器)。

- 时间:内部一律 UTC aware,边界处(输入/输出)才做本地化。

- 引入第三方前:先花 10 分钟查标准库文档,往往已经够用。

- 用 python -X dev 或 -W error 跑一遍,能让很多隐藏的弃用警告与资源泄漏直接变成错误暴露出来。


六、练习题

  1. 基础题:用 collections.Counter 统计一段英文文本中每个单词出现的次数,输出出现最多的前 5 个单词及其次数。要求:忽略大小写、忽略标点(提示:用 re.findall(r"[a-z']+", text.lower())),并写出时间复杂度(用 表示单词总数、 表示不同单词数)。
  1. 基础题:用 itertools 完成两件事:(a) 生成 [1, 2, 3] 与 ["a", "b"] 的所有 6 种配对;(b) 从一个无限自然数序列中取出第 100 到第 110 个(含头不含尾)。写出代码并说明为什么不能用列表切片。
  1. 进阶题:写一个函数 slugify(title: str) -> str,把中文标题转成 URL 友好的 slug:小写、非字母数字转成 -、连续分隔符合并、首尾去分隔符。用 re 实现,并用 timeit 比较「预编译」与「每次调用 re.sub」在 10 万次调用下的性能差异。
  1. 进阶题:写一个 parse_duration(s: str) -> timedelta 函数,解析形如 "1d2h30m"、"45s"、"2h" 的字符串。要求:(a) 用命名分组的正则一次提取所有部分;(b) 非法输入抛 ValueError 并带上原始串;(c) 用 timeit 验证单次解析在 5 微秒以内。
  1. 进阶题:写一个 secure_token(nbytes: int = 32) -> str 函数生成会话 Token,并写一个 constant_time_verify(a: str, b: str) -> bool。解释:(a) 为什么必须用 secrets 而不是 random;(b) 为什么必须用 hmac.compare_digest 而不是 ==;(c) 时序攻击具体是怎么利用 == 的短路特性的。
  1. 思考题:你要写一个读取 10 GB 日志文件并统计各 IP 出现次数的脚本。请说明:(a) 为什么不能用 json.load 或 f.read();(b) 内存占用与文件大小的关系(用 记号);(c) 如果不同 IP 的数量超过内存能容纳的上限,有什么办法(提示:外部排序、分桶、概率数据结构如 HyperLogLog / Count-Min Sketch)。

七、常见问题(FAQ)

Q1:defaultdict 和 dict.setdefault 有什么区别,该用哪个?

A:功能上都能实现「缺键时给默认值」。区别在于:

  • defaultdict 在每次缺键访问时都会创建默认值,即使你只是想检查存在性——这会悄悄往字典里塞进空值。
  • dict.setdefault(k, default) 每次都会构造 default 参数(即使是已存在的键),构造开销大时(如 [] 无所谓,expensive() 就有影响)。

选择建议:明确是「累积/分组」语义时用 defaultdict(代码最短、意图最清楚);需要「检查存在性而不修改字典」时用 k in d 或 d.get(k);setdefault 适合一次性初始化且默认值很廉价的情况。

Q2:re.compile 到底有没有必要?

A:re 模块内部有编译缓存(默认 512 条,re._MAXCACHE),所以循环里直接用 re.match(pattern, s) 不会每次重新编译。但预编译仍有三个好处:(a) 热点循环里省掉一次缓存查表与函数调用;(b) 长模式配合 re.VERBOSE 时,编译与阅读都在一处,可读性更好;(c) 编译失败会在模块加载时就暴露,而不是等到第一次调用。结论:短模式随手写,长模式或热点路径预编译。

Q3:logging 里的日志为什么有时没输出?

A:按以下顺序检查:

  1. 级别:logger 的 level 与 handler 的 level 是两个独立的门槛,两个都要通过才会输出。logger.setLevel(DEBUG) 但 handler 是 INFO 时,DEBUG 依然看不到。
  2. handler 是否存在:如果没有显式加 handler 且 propagate=True,会向上找 root 的 handler;root 也没有 handler 时,Python 会用 lastResort(只输出 WARNING 及以上到 stderr)。
  3. propagate:设成 False 会切断向上冒泡。
  4. 重复调用 basicConfig:默认只在 root 无 handler 时生效,第二次调用被忽略(用 force=True 强制重配)。
  5. Jupyter / 交互环境:某些环境预先配置了 handler,行为与脚本不同。

Q4:math 和 statistics 该用哪个算平均值?

A:简单场景两者都行,但有三点实际差别:

  1. 精度:statistics.mean 内部用 Fraction 精确累加再相除,避免浮点累积误差;fmean 直接做浮点求和,更快但精度略低。
  2. 输入类型:mean 能直接处理 Decimal、Fraction 等非浮点数字类型;fmean 会把所有输入转成 float,因此 Decimal 的精度优势会丢失。
  3. 空输入与 NaN:两者对空序列都抛 StatisticsError;输入含 nan 时结果就是 nan(不会跳过,需要自己过滤)。

结论:追求精度或输入是 Decimal 时用 mean;纯浮点、追求速度时用 fmean。数据量大或需要向量化时用 numpy/pandas,它们比纯 Python 快一到两个数量级。

Q5:subprocess 到底该不该用 shell=True?

A:默认不用。只有当你要用的功能本质上是 shell 特性时才考虑:管道 |、重定向 >、通配符 *、环境变量展开 $VAR、以及 Windows 上的内建命令(dir、copy、type)。即使用时也必须:

  • 把所有外部输入用 shlex.quote() 转义;
  • 在 Windows 上用 shlex.quote 不完全等价(Windows 的引号规则不同),最好用列表参数;
  • 记住 shell=True 时 args 是字符串,shell=False 时是列表,混用会导致难以理解的错误。

相关笔记

  • Python-02-内置数据结构 —— collections 的容器建立在 list/dict/tuple 之上
  • Python-05-异常与文件IO —— pathlib、csv、json 的文件操作与异常处理
  • Python-07-进阶特性 —— 迭代器协议与生成器是 itertools 惰性求值的基础
  • Python-03-函数与模块 —— functools 的 wraps、partial 直接服务于装饰器与参数机制
  • 工具-07-调试技巧 —— 日志与性能测量是排查问题的两大利器

参考来源

  • Python 标准库总目录:https://docs.python.org/3/library/index.html
  • collections · 容器数据类型:https://docs.python.org/3/library/collections.html
  • itertools · 为高效循环而生的迭代器:https://docs.python.org/3/library/itertools.html
  • functools · 高阶函数与可调用对象工具:https://docs.python.org/3/library/functools.html
  • datetime · 基本日期与时间类型:https://docs.python.org/3/library/datetime.html
  • zoneinfo · IANA 时区支持:https://docs.python.org/3/library/zoneinfo.html
  • re · 正则表达式操作:https://docs.python.org/3/library/re.html
  • json · JSON 编解码器:https://docs.python.org/3/library/json.html
  • random · 生成伪随机数:https://docs.python.org/3/library/random.html
  • secrets · 生成管理密码的安全随机数:https://docs.python.org/3/library/secrets.html
  • statistics · 数学统计函数:https://docs.python.org/3/library/statistics.html
  • subprocess · 子进程管理:https://docs.python.org/3/library/subprocess.html
  • logging · 日志设施(含 Cookbook):https://docs.python.org/3/library/logging.html
  • argparse · 命令行选项与参数解析:https://docs.python.org/3/library/argparse.html
  • hashlib · 安全哈希与消息摘要:https://docs.python.org/3/library/hashlib.html
  • timeit · 测量小段代码的执行时间:https://docs.python.org/3/library/timeit.html
  • PEP 20 · The Zen of Python:https://peps.python.org/pep-0020/
  • PEP 8 · Style Guide for Python Code:https://peps.python.org/pep-0008/
  • PEP 387 · Backwards Compatibility Policy(弃用流程):https://peps.python.org/pep-0387/

版本提示

functools.cache 需要 Python 3.9+;zoneinfo 需要 3.9+;statistics.fmean 需要 3.8+;datetime.UTC 别名需要 3.11+;itertools.accumulate(initial=) 需要 3.8+;logging.basicConfig(force=) 需要 3.8+。timeit 与 hashlib 的底层实现随版本优化,具体 API 与行为以官方最新文档为准:https://docs.python.org/3/whatsnew/