看懂这 15 个内置模块,Python 水平直接上一个台阶

很多 Python 项目真正把人拖垮的，并不是算法有多复杂，而是那些看似“随手就能写”的基础功能，反复出现、到处复制。日志、时间、路径、配置、并发、简单存储……这些东西每一个单独拎出来都不难，但当它们被零零散散写在各个角落时，代码很快就会变成一锅粥。深夜改 Bug 时最容易冒出来的那句话，往往不是“这算法真难”，而是“当初为什么要自己写这个”。

事实上，Python 之所以能在工程领域站稳脚跟，很大一部分原因不在第三方生态，而在标准库。标准库并不是“新手玩具”，恰恰相反，它更像是一套被无数项目反复验证过的工程级工具箱。真正写过几年 Python 的人，都会慢慢意识到一个规律：越成熟的代码，越少“自创发明”。

很多人第一次写日志，习惯性地用 print。程序跑得通，信息也能看到，于是就这么一路用下去。直到线上出问题，日志一团乱麻，分不清哪个是正常信息，哪个是异常，哪个是致命错误。这时候才发现，logging 这种东西根本不是“可选项”，而是专业代码的起点。日志级别、格式、输出位置，全都可以在配置层解决，业务代码本身只负责说清楚“发生了什么”。

import logging

# 基本配置：将INFO及以上级别日志输出到控制台
logging.basicConfig(level=logging.INFO,
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logger = logging.getLogger('MyApp')

defprocess_data(data):
    logger.info(f'开始处理数据，大小：{len(data)}')
try:
# ... 业务逻辑 ...
        logger.debug('数据处理步骤1完成') # DEBUG级别可能需要额外配置level
except Exception as e:
        logger.error(f'数据处理失败：{e}', exc_info=True)
    logger.info('数据处理完毕')

process_data([1, 2, 3])

当日志这件事被标准化之后，很多隐藏的问题会自动浮出水面。哪些地方该打 INFO，哪些地方只能打 DEBUG，哪些错误必须报警，这些都会反过来逼着开发者重新审视代码结构。

路径处理也是一个典型的“低估风险点”。字符串拼路径的时候，短期看不出问题，跨平台、路径层级一复杂，就开始踩坑。pathlib 把路径从字符串，变成了对象，这个转变看似细微，实则非常重要。路径不再是“拼出来的”，而是“组合出来的”。

from pathlib import Path

# 优雅地拼接路径（跨平台兼容）
project_root = Path.home() / 'projects' / 'my_app'
config_file = project_root / 'config' / 'settings.yaml'

# 检查路径和文件属性
if config_file.exists() and config_file.is_file():
    print(f"配置文件大小：{config_file.stat().st_size} 字节")

# 遍历目录
for py_file in project_root.rglob('*.py'): # 递归查找所有.py文件
    print(py_file.relative_to(project_root)) # 输出相对路径

# 创建新目录及其父目录
log_dir = project_root / 'logs' / '2024'
log_dir.mkdir(parents=True, exist_ok=True)

当脚本开始被更多人使用，命令行接口的质量直接决定了“工具感”。argparse 在这里几乎是唯一正确的选择。参数校验、默认值、帮助文档，全都自动生成，代码不仅更稳，也更像一个“正经工具”。

import argparse

defcreate_parser():
    parser = argparse.ArgumentParser(description='一个文件处理工具示例')
# 必需的位置参数
    parser.add_argument('input_dir', type=str, help='输入目录的路径')
# 可选参数
    parser.add_argument('-o', '--output', default='./output', help='输出目录路径（默认：./output）')
    parser.add_argument('-r', '--recursive', action='store_true', help='是否递归处理子目录')
# 带类型验证和选择的参数
    parser.add_argument('--mode', choices=['copy', 'move', 'link'], default='copy', help='处理模式')
    parser.add_argument('--threads', type=int, default=1, help='并发线程数')
return parser

if __name__ == '__main__':
    parser = create_parser()
    args = parser.parse_args()
    print(f"将处理目录：{args.input_dir}")
    print(f"输出到：{args.output}，模式：{args.mode}")
if args.recursive:
        print("启用递归模式")

数据交换层面，json 和 datetime 几乎是绕不开的组合。一个负责结构，一个负责时间。很多线上事故，追根溯源都和“时间处理不规范”有关。字符串时间满天飞，时区没人管，迟早要炸。

import json

# 序列化Python对象到JSON字符串
data = {
'project': 'Demo',
'authors': ['Alice', 'Bob'],
'version': 1.2,
'config': {'debug': True}
}
json_str = json.dumps(data, indent=2, ensure_ascii=False) # 美化输出，支持中文
print(json_str)

# 将JSON字符串写文件
config_path = Path('config.json')
config_path.write_text(json_str, encoding='utf-8')

# 从字符串或文件反序列化
loaded_data = json.loads(json_str)
loaded_from_file = json.loads(config_path.read_text(encoding='utf-8'))

assert data == loaded_data

from datetime import datetime, date, timedelta

# 获取当前时间（本地）和UTC时间
now_local = datetime.now()
now_utc = datetime.utcnow()
print(f'本地时间: {now_local}')
print(f'UTC时间: {now_utc}')

# 时间的创建与格式化
birthday = date(1990, 8, 15)
appointment = datetime(2024, 10, 1, 14, 30)
formatted = appointment.strftime('%Y年%m月%d日 %H:%M')
print(f'预约时间: {formatted}')

# 时间间隔计算
new_date = appointment + timedelta(days=7, hours=3)
time_diff = new_date - appointment
print(f'七天三小时后的时间: {new_date}')
print(f'时间差为: {time_diff}， 总计 {time_diff.total_seconds()} 秒')

# 解析字符串为时间对象
parsed_time = datetime.strptime('2024-01-01 12:00', '%Y-%m-%d %H:%M')

collections、itertools、functools 这三组模块，往往决定了一段代码“像不像高手写的”。不是为了炫技，而是为了少写判断、少写中间变量、少写临时结构。

from collections import defaultdict, Counter, deque, namedtuple

# 1. defaultdict - 分组统计
dept_employees = defaultdict(list)
employees = [('研发部', '张三'), ('市场部', '李四'), ('研发部', '王五')]
for dept, name in employees:
    dept_employees[dept].append(name) # 无需判断key是否存在！
print(dict(dept_employees))

# 2. Counter - 词频统计
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_counts = Counter(words)
print(f'最常见的两个词: {word_counts.most_common(2)}')

# 3. deque - 维护最近十条记录
recent_logs = deque(maxlen=10)
for i in range(15):
    recent_logs.append(f'Log_{i}')
print(f'最新的10条日志: {list(recent_logs)}') # Log_5 到 Log_14

# 4. namedtuple - 清晰的坐标点
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(f'点坐标: ({p.x}, {p.y})') # 比 p[0], p[1] 清晰得多

import itertools

# 1. 无限序列生成器
counter = itertools.count(start=10, step=2) # 从10开始，步长为2的无限计数器
print(list(next(counter) for _ in range(5))) # [10, 12, 14, 16, 18]

# 2. 连接多个可迭代对象
chained = itertools.chain([1, 2], 'AB', (i for i in range(3)))
print(list(chained)) # [1, 2, 'A', 'B', 0, 1, 2]

# 3. 分组操作（需先排序）
data = sorted([('A', 1), ('B', 2), ('A', 3), ('B', 4)], key=lambda x: x[0](@ref)
for key, group in itertools.groupby(data, key=lambda x: x[0](@ref):
    print(f'Key: {key}, Items: {list(group)}')

# 4. 组合与排列
print('所有两两组合:', list(itertools.combinations('ABC', 2)))
print('所有排列:', list(itertools.permutations('AB', 2)))

并发、数据类、类型提示、正则、系统交互、轻量数据库，这些模块并不“高级”，但它们拼在一起，刚好覆盖了绝大多数真实业务脚本的核心需求。写得越久，越能体会到一种变化：从“怎么实现功能”，变成“怎么让代码更稳、更久”。

from functools import lru_cache, partial, wraps
import time

from concurrent.futures import ThreadPoolExecutor, as_completed
import requests

from dataclasses import dataclass, field, asdict, astuple

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

import re

import sys
import os

import csv
import sqlite3

当一个人开始下意识地先翻标准库文档，而不是先 pip install，一个明显的变化会发生：代码开始变轻，思路开始变清晰，Bug 出现的频率也在下降。所谓“避免重复造轮子”，从来不是偷懒，而是一种对工程经验的尊重。真正成熟的开发者，往往把力气花在“组合轮子”上，而不是在地上重新烧铁……