第09章-标准库与常用模块

9.1 数据序列化

9.1.1 JSON模块

import json

# Python对象转JSON字符串
data = {
    "name": "Alice",
    "age": 25,
    "hobbies": ["reading", "music"],
    "married": False
}

# dumps() - 转为JSON字符串
json_str = json.dumps(data)
print(json_str)
# {"name": "Alice", "age": 25, "hobbies": ["reading", "music"], "married": false}

# 格式化输出
json_str = json.dumps(data, indent=4)
print(json_str)

# 确保中文正常显示
data_cn = {"姓名": "张三", "年龄": 30}
json_str = json.dumps(data_cn, ensure_ascii=False)
print(json_str)  # {"姓名": "张三", "年龄": 30}

# JSON字符串转Python对象
json_str = '{"name": "Bob", "age": 30}'
data = json.loads(json_str)
print(data)  # {'name': 'Bob', 'age': 30}
print(type(data))  # <class 'dict'>

# 写入文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

# 从文件读取
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)
    print(loaded_data)

# 自定义对象序列化
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def person_encoder(obj):
    if isinstance(obj, Person):
        return {"name": obj.name, "age": obj.age}
    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

person = Person("Alice", 25)
json_str = json.dumps(person, default=person_encoder)
print(json_str)

# 或使用自定义编码器类
class PersonEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Person):
            return {"name": obj.name, "age": obj.age}
        return super().default(obj)

json_str = json.dumps(person, cls=PersonEncoder)
print(json_str)

9.1.2 Pickle模块

import pickle

# Python对象序列化（二进制）
data = {
    "name": "Alice",
    "age": 25,
    "hobbies": ["reading", "music"]
}

# dumps() - 序列化为bytes
pickled = pickle.dumps(data)
print(pickled)  # b'\x80\x04\x95...'
print(type(pickled))  # <class 'bytes'>

# loads() - 反序列化
unpickled = pickle.loads(pickled)
print(unpickled)

# 写入文件（二进制模式）
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

# 从文件读取
with open("data.pkl", "rb") as f:
    loaded = pickle.load(f)
    print(loaded)

# Pickle可以序列化更多Python对象
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Bob", 30)

# 序列化自定义对象
with open("person.pkl", "wb") as f:
    pickle.dump(person, f)

with open("person.pkl", "rb") as f:
    loaded_person = pickle.load(f)
    print(f"{loaded_person.name}, {loaded_person.age}")

# 注意：Pickle不安全，不要反序列化不信任的数据

9.1.3 CSV模块

import csv

# 写入CSV
data = [
    ["姓名", "年龄", "城市"],
    ["Alice", 25, "北京"],
    ["Bob", 30, "上海"],
    ["Charlie", 35, "广州"]
]

with open("data.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(data)

# 读取CSV
with open("data.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 使用DictWriter
data = [
    {"name": "Alice", "age": 25, "city": "北京"},
    {"name": "Bob", "age": 30, "city": "上海"}
]

with open("data.csv", "w", newline="", encoding="utf-8") as f:
    fieldnames = ["name", "age", "city"]
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(data)

# 使用DictReader
with open("data.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']}: {row['age']}岁，来自{row['city']}")

# 自定义分隔符
with open("data.tsv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f, delimiter="\t")
    writer.writerows(data)

9.1.4 XML处理

import xml.etree.ElementTree as ET

# 创建XML
root = ET.Element("students")

student1 = ET.SubElement(root, "student")
ET.SubElement(student1, "name").text = "Alice"
ET.SubElement(student1, "age").text = "25"

student2 = ET.SubElement(root, "student")
ET.SubElement(student2, "name").text = "Bob"
ET.SubElement(student2, "age").text = "30"

# 生成XML树
tree = ET.ElementTree(root)
tree.write("students.xml", encoding="utf-8", xml_declaration=True)

# 读取XML
tree = ET.parse("students.xml")
root = tree.getroot()

for student in root.findall("student"):
    name = student.find("name").text
    age = student.find("age").text
    print(f"{name}: {age}岁")

---

9.2 时间与日期

9.2.1 datetime模块

from datetime import datetime, date, time, timedelta

# 获取当前时间
now = datetime.now()
print(now)  # 2026-01-01 12:00:00.123456

today = date.today()
print(today)  # 2026-01-01

# 创建日期时间对象
dt = datetime(2026, 1, 1, 12, 30, 45)
print(dt)

d = date(2026, 1, 1)
print(d)

t = time(12, 30, 45)
print(t)

# 格式化输出
print(now.strftime("%Y-%m-%d %H:%M:%S"))
print(now.strftime("%Y年%m月%d日 %H时%M分%S秒"))
print(now.strftime("%A, %B %d, %Y"))

# 常用格式化符号
# %Y - 四位年份  %y - 两位年份
# %m - 月份(01-12)  %B - 月份名称  %b - 月份缩写
# %d - 日期(01-31)
# %H - 小时(00-23)  %I - 小时(01-12)
# %M - 分钟(00-59)
# %S - 秒(00-59)
# %A - 星期名称  %a - 星期缩写
# %p - AM/PM

# 解析字符串为日期时间
date_str = "2026-01-01 12:30:45"
dt = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(dt)

# 时间计算
now = datetime.now()

# 加减时间
tomorrow = now + timedelta(days=1)
yesterday = now - timedelta(days=1)
next_week = now + timedelta(weeks=1)
next_hour = now + timedelta(hours=1)

print(f"明天：{tomorrow}")
print(f"昨天：{yesterday}")

# 时间差
date1 = datetime(2026, 1, 1)
date2 = datetime(2026, 12, 31)
diff = date2 - date1
print(f"相差{diff.days}天")
print(f"相差{diff.total_seconds()}秒")

# 日期属性
dt = datetime.now()
print(f"年：{dt.year}")
print(f"月：{dt.month}")
print(f"日：{dt.day}")
print(f"小时：{dt.hour}")
print(f"分钟：{dt.minute}")
print(f"秒：{dt.second}")
print(f"星期几：{dt.weekday()}")  # 0-6，0是星期一

9.2.2 time模块

import time

# 获取当前时间戳
timestamp = time.time()
print(timestamp)  # 1735747200.123456

# 暂停执行
print("开始")
time.sleep(2)  # 暂停2秒
print("2秒后")

# 计时
start = time.time()
# 执行一些操作
for i in range(1000000):
    pass
end = time.time()
print(f"耗时：{end - start}秒")

# 时间元组
local_time = time.localtime()
print(local_time)
# time.struct_time(tm_year=2026, tm_mon=1, tm_mday=1, ...)

# 格式化
formatted = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(formatted)

# 性能计数器（更精确）
start = time.perf_counter()
time.sleep(0.1)
end = time.perf_counter()
print(f"精确耗时：{end - start}秒")

9.2.3 calendar模块

import calendar

# 打印日历
print(calendar.month(2026, 1))

# 打印全年日历
print(calendar.calendar(2026))

# 判断闰年
print(calendar.isleap(2024))  # True
print(calendar.isleap(2025))  # False

# 某月有多少天
print(calendar.monthrange(2026, 2))  # (6, 28) - 2月1日是星期六，有28天

# 星期几
print(calendar.weekday(2026, 1, 1))  # 3（星期四）

# 月份第一天是星期几
calendar.setfirstweekday(calendar.SUNDAY)  # 设置周日为一周的第一天

---

9.3 正则表达式

9.3.1 re模块基础

import re

# 匹配模式
text = "Hello, my phone number is 138-1234-5678"

# search() - 搜索第一个匹配
match = re.search(r"\d{3}-\d{4}-\d{4}", text)
if match:
    print(match.group())  # 138-1234-5678
    print(match.start())  # 匹配开始位置
    print(match.end())    # 匹配结束位置

# match() - 从字符串开头匹配
text = "Python is great"
match = re.match(r"Python", text)
if match:
    print(match.group())  # Python

# 不匹配
match = re.match(r"Java", text)
print(match)  # None

# findall() - 查找所有匹配
text = "My numbers are 123, 456, and 789"
numbers = re.findall(r"\d+", text)
print(numbers)  # ['123', '456', '789']

# finditer() - 返回迭代器
for match in re.finditer(r"\d+", text):
    print(match.group(), match.start(), match.end())

# split() - 分割字符串
text = "apple,banana;cherry orange"
fruits = re.split(r"[,;\s]+", text)
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']

# sub() - 替换
text = "My phone is 138-1234-5678"
new_text = re.sub(r"\d", "*", text)
print(new_text)  # My phone is ***-****-****

# 替换并限制次数
new_text = re.sub(r"\d", "*", text, count=3)
print(new_text)  # My phone is ***-1234-5678

9.3.2 正则表达式语法

# 基本字符
# . - 任意字符（除换行符）
# \d - 数字[0-9]
# \D - 非数字
# \w - 字母数字下划线[a-zA-Z0-9_]
# \W - 非字母数字下划线
# \s - 空白字符
# \S - 非空白字符

# 量词
# * - 0次或多次
# + - 1次或多次
# ? - 0次或1次
# {n} - 恰好n次
# {n,} - 至少n次
# {n,m} - n到m次

# 示例
print(re.findall(r"\d+", "a1b22c333"))  # ['1', '22', '333']
print(re.findall(r"\d{3}", "12 123 1234"))  # ['123', '123']
print(re.findall(r"\d{2,4}", "1 12 123 1234"))  # ['12', '123', '1234']

# 字符类
# [abc] - a或b或c
# [a-z] - a到z
# [^abc] - 除了a、b、c

print(re.findall(r"[aeiou]", "hello"))  # ['e', 'o']
print(re.findall(r"[^aeiou]", "hello"))  # ['h', 'l', 'l']

# 边界匹配
# ^ - 字符串开头
# $ - 字符串结尾
# \b - 单词边界

text = "The cat sat on the mat"
print(re.findall(r"\bcat\b", text))  # ['cat']
print(re.findall(r"\bcat", "catalog"))  # ['cat']

# 分组
# () - 分组
# | - 或

match = re.search(r"(\d{3})-(\d{4})-(\d{4})", "138-1234-5678")
if match:
    print(match.group(0))  # 完整匹配：138-1234-5678
    print(match.group(1))  # 第一组：138
    print(match.group(2))  # 第二组：1234
    print(match.group(3))  # 第三组：5678
    print(match.groups())  # 所有组：('138', '1234', '5678')

# 命名分组
match = re.search(r"(?P<area>\d{3})-(?P<prefix>\d{4})-(?P<number>\d{4})",
                  "138-1234-5678")
if match:
    print(match.group("area"))    # 138
    print(match.group("prefix"))  # 1234
    print(match.groupdict())      # {'area': '138', 'prefix': '1234', 'number': '5678'}

9.3.3 编译正则表达式

# 编译正则表达式（提高性能）
pattern = re.compile(r"\d{3}-\d{4}-\d{4}")

# 使用编译后的模式
text = "Phone: 138-1234-5678"
match = pattern.search(text)
print(match.group())

# 标志
# re.IGNORECASE (re.I) - 忽略大小写
# re.MULTILINE (re.M) - 多行模式
# re.DOTALL (re.S) - .匹配所有字符包括换行符
# re.VERBOSE (re.X) - 详细模式，可以添加注释

pattern = re.compile(r"python", re.IGNORECASE)
print(pattern.findall("Python is great, python rocks!"))
# ['Python', 'python']

# 详细模式
pattern = re.compile(r"""
    (\d{3})  # 区号
    -        # 分隔符
    (\d{4})  # 前缀
    -        # 分隔符
    (\d{4})  # 号码
""", re.VERBOSE)

match = pattern.search("138-1234-5678")
print(match.groups())

9.3.4 实用案例

# 邮箱验证
def is_valid_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None

print(is_valid_email("user@example.com"))  # True
print(is_valid_email("invalid.email"))     # False

# 手机号验证
def is_valid_phone(phone):
    pattern = r'^1[3-9]\d{9}$'
    return re.match(pattern, phone) is not None

print(is_valid_phone("13812345678"))  # True
print(is_valid_phone("12345678901"))  # False

# 提取URL
text = "Visit https://www.example.com and http://test.com"
urls = re.findall(r'https?://[^\s]+', text)
print(urls)  # ['https://www.example.com', 'http://test.com']

# 提取HTML标签内容
html = "<div>Hello</div><p>World</p>"
content = re.findall(r'<[^>]+>(.*?)</[^>]+>', html)
print(content)  # ['Hello', 'World']

# 移除HTML标签
clean_text = re.sub(r'<[^>]+>', '', html)
print(clean_text)  # HelloWorld

---

9.4 集合与队列

9.4.1 collections模块

from collections import Counter, defaultdict, OrderedDict, deque, namedtuple

# Counter - 计数器
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
counter = Counter(words)
print(counter)  # Counter({'apple': 3, 'banana': 2, 'cherry': 1})

# 最常见的元素
print(counter.most_common(2))  # [('apple', 3), ('banana', 2)]

# 统计字符
text = "hello world"
char_count = Counter(text)
print(char_count)  # Counter({'l': 3, 'o': 2, ...})

# defaultdict - 默认字典
# 不存在的键自动创建默认值
dd = defaultdict(int)  # 默认值为0
dd["a"] += 1
dd["b"] += 2
print(dd)  # defaultdict(<class 'int'>, {'a': 1, 'b': 2})

# 列表默认值
dd = defaultdict(list)
dd["fruits"].append("apple")
dd["fruits"].append("banana")
dd["vegetables"].append("carrot")
print(dd)

# 分组
students = [
    {"name": "Alice", "class": "A"},
    {"name": "Bob", "class": "B"},
    {"name": "Charlie", "class": "A"}
]

groups = defaultdict(list)
for student in students:
    groups[student["class"]].append(student["name"])

print(dict(groups))
# {'A': ['Alice', 'Charlie'], 'B': ['Bob']}

# OrderedDict - 有序字典（Python 3.7+普通dict已有序）
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3
print(od)

# deque - 双端队列
d = deque()

# 右侧添加
d.append(1)
d.append(2)
d.append(3)
print(d)  # deque([1, 2, 3])

# 左侧添加
d.appendleft(0)
print(d)  # deque([0, 1, 2, 3])

# 右侧弹出
d.pop()
print(d)  # deque([0, 1, 2])

# 左侧弹出
d.popleft()
print(d)  # deque([1, 2])

# 旋转
d = deque([1, 2, 3, 4, 5])
d.rotate(2)  # 向右旋转2个位置
print(d)  # deque([4, 5, 1, 2, 3])

# 限制长度
d = deque(maxlen=3)
for i in range(5):
    d.append(i)
    print(d)
# deque([0], maxlen=3)
# deque([0, 1], maxlen=3)
# deque([0, 1, 2], maxlen=3)
# deque([1, 2, 3], maxlen=3)
# deque([2, 3, 4], maxlen=3)

# namedtuple - 命名元组
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)  # 10 20
print(p[0], p[1])  # 10 20

Person = namedtuple('Person', ['name', 'age', 'city'])
alice = Person('Alice', 25, 'Beijing')
print(alice.name)  # Alice

9.4.2 heapq模块

import heapq

# 堆（优先队列）
numbers = [5, 1, 8, 3, 2, 9, 4, 7, 6]

# 转换为堆
heapq.heapify(numbers)
print(numbers)  # [1, 2, 4, 3, 5, 9, 8, 7, 6]

# 弹出最小元素
smallest = heapq.heappop(numbers)
print(smallest)  # 1
print(numbers)   # [2, 3, 4, 6, 5, 9, 8, 7]

# 添加元素
heapq.heappush(numbers, 0)
print(numbers)  # [0, 2, 4, 3, 5, 9, 8, 7, 6]

# 最小的n个元素
numbers = [5, 1, 8, 3, 2, 9, 4, 7, 6]
print(heapq.nsmallest(3, numbers))  # [1, 2, 3]

# 最大的n个元素
print(heapq.nlargest(3, numbers))  # [9, 8, 7]

# 根据属性排序
students = [
    {"name": "Alice", "score": 85},
    {"name": "Bob", "score": 92},
    {"name": "Charlie", "score": 78}
]

top_students = heapq.nlargest(2, students, key=lambda s: s["score"])
print(top_students)
# [{'name': 'Bob', 'score': 92}, {'name': 'Alice', 'score': 85}]

---

9.5 其他常用模块

9.5.1 sys模块

import sys

# 命令行参数
print(sys.argv)  # ['script.py', 'arg1', 'arg2']

# Python版本
print(sys.version)
print(sys.version_info)

# 模块搜索路径
print(sys.path)

# 退出程序
# sys.exit(0)  # 正常退出
# sys.exit(1)  # 异常退出

# 标准输入输出
sys.stdout.write("Hello\n")
# line = sys.stdin.readline()

# 最大整数
print(sys.maxsize)

# 递归深度
print(sys.getrecursionlimit())  # 默认1000
# sys.setrecursionlimit(2000)

# 平台信息
print(sys.platform)  # 'win32', 'linux', 'darwin'

9.5.2 logging模块

import logging

# 基本配置
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log',
    filemode='w'
)

# 日志级别
logging.debug("调试信息")
logging.info("一般信息")
logging.warning("警告信息")
logging.error("错误信息")
logging.critical("严重错误")

# 创建logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# 创建处理器
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')

# 设置级别
console_handler.setLevel(logging.INFO)
file_handler.setLevel(logging.DEBUG)

# 创建格式器
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

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

# 使用logger
logger.debug("这是调试信息")
logger.info("这是一般信息")
logger.error("这是错误信息")

9.5.3 argparse模块

import argparse

# 创建解析器
parser = argparse.ArgumentParser(description="示例程序")

# 添加参数
parser.add_argument("name", help="姓名")
parser.add_argument("age", type=int, help="年龄")
parser.add_argument("-v", "--verbose", action="store_true", help="详细输出")
parser.add_argument("-o", "--output", default="output.txt", help="输出文件")

# 解析参数
args = parser.parse_args()

# 使用参数
print(f"姓名：{args.name}")
print(f"年龄：{args.age}")
if args.verbose:
    print("详细模式")
print(f"输出到：{args.output}")

# 运行示例：
# python script.py Alice 25 -v -o result.txt

---

9.6 参考资料

官方文档

• 标准库概览：https://docs.python.org/zh-cn/3/tutorial/stdlib.html
• json模块：https://docs.python.org/zh-cn/3/library/json.html
• re模块：https://docs.python.org/zh-cn/3/library/re.html
• datetime模块：https://docs.python.org/zh-cn/3/library/datetime.html
• collections模块：https://docs.python.org/zh-cn/3/library/collections.html

学习资源

• 菜鸟教程-JSON：https://www.runoob.com/python3/python3-json.html
• 菜鸟教程-正则表达式：https://www.runoob.com/python3/python3-reg-expressions.html
• 正则表达式在线测试：https://regex101.com/

工具

• 正则表达式可视化：https://regexper.com/
• JSON格式化：https://jsonformatter.org/
• 时间戳转换：https://tool.lu/timestamp/