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 %S | 24 小时制时/分/秒 | 14:30:05 |
%f | 微秒(6 位) | 123456 |
%z | UTC 偏移 | +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()之外的时间戳做运算,跨时区、跨夏令时的算术一律用 awaredatetime+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 或 None | None | 只从开头匹配 |
re.fullmatch(p, s) | Match 或 None | None | 要求整串匹配(校验格式首选) |
re.search(p, s) | Match 或 None | None | 任意位置首次出现 |
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 是密码学安全随机。
| 维度 | random | secrets |
|---|---|---|
| 算法 | 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.Path | os.path |
| 遍历目录树 | Path.rglob / os.walk | os.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:
| 维度 | print | logging |
|---|---|---|
| 级别 | 无 | DEBUG/INFO/WARNING/ERROR/CRITICAL |
| 输出目标 | 只能 stdout | 文件、stderr、网络、syslog 多路同时 |
| 开关 | 要改代码 | 改配置/环境变量即可 |
| 时间戳与位置 | 需手写 | 格式串自动带 |
| 性能 | 总是执行 | 级别不满足时跳过格式化 |
| 多线程安全 | 不保证 | 内置锁保护 |
| 生产可用性 | 不可 | 可(轮转、结构化、接入监控) |
| 库内使用 | 禁止 | ✅ 加 NullHandler 静默 |
五个级别(数值越大越严重):
| 级别 | 数值 | 何时用 |
|---|---|---|
DEBUG | 10 | 诊断细节:变量值、分支走向、SQL 原文 |
INFO | 20 | 正常里程碑:服务启动、任务完成、用户登录 |
WARNING | 30 | 可继续但需注意:重试成功、配置缺失用默认值、弃用提醒 |
ERROR | 40 | 功能失败但程序还能跑:请求处理失败、写文件失败 |
CRITICAL | 50 | 程序无法继续:数据库连不上、关键依赖缺失 |
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)s | logger 名(通常就是模块名) |
%(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:哈希与校验
哈希函数把任意长度的输入映射成固定长度的摘要:
三条性质决定了它的用途:
- 确定性:同样的输入永远得到同样的输出(可用于校验、去重、缓存键)。
- 抗原像性:从 反推 在计算上不可行(可用于存密码——但要加盐 + 慢哈希)。
- 抗碰撞性:找到 且 在计算上不可行(可用于签名、去重)。
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
| 算法 | 摘要长度 | 安全状态 | 用途 |
|---|---|---|---|
md5 | 128 bit | ❌ 已被攻破(碰撞可在秒级构造) | 仅非安全校验(如去重、缓存键) |
sha1 | 160 bit | ❌ 已不推荐(SHAttered 攻击) | 遗留系统兼容 |
sha256 / sha512 | 256 / 512 bit | ✅ 安全 | 通用校验、签名、HMAC |
sha3_256 | 256 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/次")
| 对比项 | timeit | time.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.Counter | dict + get |
| 分组 | collections.defaultdict(list) | itertools.groupby(需先排序) |
| 队列 / BFS | collections.deque | queue.Queue(多线程) |
| 固定字段的记录 | collections.namedtuple | dataclasses.dataclass |
| 惰性迭代、笛卡尔积 | itertools | 手写生成器 |
| 记忆化 | functools.lru_cache | 手写 dict |
| 时间戳 → 字符串 | datetime.strftime | f-string 格式化 |
| 字符串解析 | re | str.split(简单场景更快更清楚) |
| 解析 JSON | json | orjson(性能)、pydantic(校验) |
| 随机数(非安全) | random | — |
| 随机数(安全) | secrets | os.urandom |
| 数学函数 | math | numpy(数组) |
| 统计量 | statistics | numpy / pandas |
| 执行外部命令 | subprocess.run([...]) | shlex + shell=True(慎用) |
| 日志 | logging | 结构化日志第三方库 |
| 命令行解析 | argparse | click / typer |
| 哈希校验 | hashlib.sha256 | blake2b |
| 密码存储 | hashlib.scrypt | argon2-cffi |
| 性能测量 | timeit | cProfile(找热点) |
四、怎么用
一个端到端的小工具:扫描目录下的日志文件,按级别统计并输出 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())
各模块在其中的分工:
| 模块 | 用在哪里 | 为什么这么选 |
|---|---|---|
argparse | build_parser | 零依赖的 CLI,自动生成 -h |
pathlib | root.rglob("*.log") | 面向对象路径,递归匹配 |
itertools.islice | iter_lines | 预览前 N 行不读全文 |
re(预编译 + 命名分组) | LINE_RE | 循环里复用编译结果,分组名可读 |
functools.lru_cache | parse_ts | 同格式时间戳重复出现,避免重复解析 |
collections.Counter | levels | 计数 + most_common |
collections.defaultdict | per_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跑一遍,能让很多隐藏的弃用警告与资源泄漏直接变成错误暴露出来。
六、练习题
- 基础题:用
collections.Counter统计一段英文文本中每个单词出现的次数,输出出现最多的前 5 个单词及其次数。要求:忽略大小写、忽略标点(提示:用re.findall(r"[a-z']+", text.lower())),并写出时间复杂度(用 表示单词总数、 表示不同单词数)。
- 基础题:用
itertools完成两件事:(a) 生成[1, 2, 3]与["a", "b"]的所有 6 种配对;(b) 从一个无限自然数序列中取出第 100 到第 110 个(含头不含尾)。写出代码并说明为什么不能用列表切片。
- 进阶题:写一个函数
slugify(title: str) -> str,把中文标题转成 URL 友好的 slug:小写、非字母数字转成-、连续分隔符合并、首尾去分隔符。用re实现,并用timeit比较「预编译」与「每次调用re.sub」在 10 万次调用下的性能差异。
- 进阶题:写一个
parse_duration(s: str) -> timedelta函数,解析形如"1d2h30m"、"45s"、"2h"的字符串。要求:(a) 用命名分组的正则一次提取所有部分;(b) 非法输入抛ValueError并带上原始串;(c) 用timeit验证单次解析在 5 微秒以内。
- 进阶题:写一个
secure_token(nbytes: int = 32) -> str函数生成会话 Token,并写一个constant_time_verify(a: str, b: str) -> bool。解释:(a) 为什么必须用secrets而不是random;(b) 为什么必须用hmac.compare_digest而不是==;(c) 时序攻击具体是怎么利用==的短路特性的。
- 思考题:你要写一个读取 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:按以下顺序检查:
- 级别:logger 的
level与 handler 的level是两个独立的门槛,两个都要通过才会输出。logger.setLevel(DEBUG)但 handler 是INFO时,DEBUG 依然看不到。 - handler 是否存在:如果没有显式加 handler 且
propagate=True,会向上找 root 的 handler;root 也没有 handler 时,Python 会用lastResort(只输出 WARNING 及以上到 stderr)。 propagate:设成False会切断向上冒泡。- 重复调用
basicConfig:默认只在 root 无 handler 时生效,第二次调用被忽略(用force=True强制重配)。 - Jupyter / 交互环境:某些环境预先配置了 handler,行为与脚本不同。
Q4:math 和 statistics 该用哪个算平均值?
A:简单场景两者都行,但有三点实际差别:
- 精度:
statistics.mean内部用Fraction精确累加再相除,避免浮点累积误差;fmean直接做浮点求和,更快但精度略低。 - 输入类型:
mean能直接处理Decimal、Fraction等非浮点数字类型;fmean会把所有输入转成float,因此Decimal的精度优势会丢失。 - 空输入与 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.htmlitertools· 为高效循环而生的迭代器:https://docs.python.org/3/library/itertools.htmlfunctools· 高阶函数与可调用对象工具:https://docs.python.org/3/library/functools.htmldatetime· 基本日期与时间类型:https://docs.python.org/3/library/datetime.htmlzoneinfo· IANA 时区支持:https://docs.python.org/3/library/zoneinfo.htmlre· 正则表达式操作:https://docs.python.org/3/library/re.htmljson· JSON 编解码器:https://docs.python.org/3/library/json.htmlrandom· 生成伪随机数:https://docs.python.org/3/library/random.htmlsecrets· 生成管理密码的安全随机数:https://docs.python.org/3/library/secrets.htmlstatistics· 数学统计函数:https://docs.python.org/3/library/statistics.htmlsubprocess· 子进程管理:https://docs.python.org/3/library/subprocess.htmllogging· 日志设施(含 Cookbook):https://docs.python.org/3/library/logging.htmlargparse· 命令行选项与参数解析:https://docs.python.org/3/library/argparse.htmlhashlib· 安全哈希与消息摘要:https://docs.python.org/3/library/hashlib.htmltimeit· 测量小段代码的执行时间: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/