你使用过哪些Python标准库模块？ #

请详细说明常用模块的用途、基本用法以及实际应用场景

Python标准库是Python语言的重要组成部分，包含了大量实用的模块，涵盖了文件操作、网络编程、数据处理、数学计算等各个方面。掌握常用标准库模块的使用是Python开发者的基本技能。

请详细说明你使用过的Python标准库模块，包括其用途、基本用法、实际应用场景，以及不同模块之间的区别和联系。

1. 核心概念概述 #

Python标准库是Python语言的核心组成部分，提供了丰富的内置模块和功能。这些模块涵盖了日常开发中的各种需求，从基础的文件操作到高级的网络编程，从简单的数学计算到复杂的数据处理。

主要分类

• 系统相关：os、sys、subprocess等
• 数据处理：json、csv、xml、pickle等
• 网络编程：socket、urllib、http等
• 数学计算：math、random、statistics等
• 日期时间：datetime、time等
• 文本处理：re、string等
• 数据结构：collections、itertools等
• 函数工具：functools、operator等

模块	主要用途	典型应用场景
os	操作系统交互，文件/目录管理	跨平台文件操作、自动化批处理、获取路径、环境变量
sys	访问Python解释器和命令行参数	处理脚本参数、退出程序、路径操作、调试
subprocess	启动和管理子进程	调用系统命令、批量处理自动化
json	JSON数据解析与生成	Web接口通信、数据序列化/反序列化
csv	CSV文件读写	数据导入/导出、数据清洗、与Excel兼容
pickle	Python对象序列化和反序列化	缓存对象、保存模型、数据快照
re	正则表达式处理	文本提取、模式查找/替换、数据清洗
math	数学运算和常量	科学计算、概率统计、工程分析
random	随机数生成和随机选择	抽样算法、模拟数据、游戏开发
datetime	日期和时间处理	日志记录、定时任务、时间戳计算
time	时间戳与计时功能	性能分析、程序等待、倒计时
collections	容器数据结构(如Counter, deque等)	计数统计、高效队列/栈操作、字典拓展
itertools	高性能迭代器函数	组合/排列/分组、懒加载、算法性能优化
functools	高阶函数工具(如lru_cache, partial)	装饰器开发、函数缓存、偏函数生成
operator	对象/元素的快速函数式操作	排序、加减乘除、提高代码表达力和效率

2. 系统相关模块 #

2.1 os模块 - 操作系统交互 #

os模块提供了与操作系统交互的功能，包括文件和目录操作、环境变量访问、进程管理等。

方法/属性	作用/用途	示例	说明与常见应用场景
os.getcwd()	获取当前工作目录的绝对路径	os.getcwd()	脚本中用于确定项目根目录、日志输出路径等
os.listdir(path)	列出指定目录下所有文件和子目录名	os.listdir('.')	常用于遍历文件夹、批量处理文档/图片等
os.path.exists(path)	检查文件或文件夹是否存在	os.path.exists('test_file.txt')	程序运行前进行资源校验，避免文件缺失导致异常
os.path.getsize(path)	获取指定文件的字节大小	os.path.getsize('test_file.txt')	统计文件大小、磁盘空间占用等场景
os.makedirs(path)	递归创建目录（如中间目录不存在一并创建）	os.makedirs('test_directory')	自动化批量生成目录结构，数据分批归档、下载等
os.environ	获取或设置系统环境变量（字典接口）	os.environ.get('HOME') os.environ['TEST_VAR']='x'	常用于跨平台配置、读取密钥、动态调整程序行为等，如读取用户家目录环境变量
os.environ.get(k, d)	获取环境变量k，不存在时返回d	os.environ.get('HOME', '未设置')	避免KeyError异常，提供默认值

# 导入os模块，用于操作系统交互
import os
# 导入time模块，用于时间操作
import time

 # 获取当前工作目录
current_directory = os.getcwd()
# 打印当前工作目录
print(f"当前工作目录: {current_directory}")

# 列出当前目录下的所有文件和子目录
files_and_dirs = os.listdir('.')
# 打印列出的内容
print(f"当前目录内容: {files_and_dirs}")

# 检查文件或目录是否存在
exists = os.path.exists('test_file.txt')
# 打印文件是否存在
print(f"test_file.txt 是否存在: {exists}")

# 获取文件大小
if os.path.exists('test_file.txt'):
    # 如果文件存在
    file_size = os.path.getsize('test_file.txt')
    # 获取文件大小
    print(f"test_file.txt 文件大小: {file_size} 字节")

# 创建目录
test_dir = 'test_directory'
# 设置测试目录名
if not os.path.exists(test_dir):
    # 如果目录不存在
    os.makedirs(test_dir)
    # 创建目录
    print(f"创建目录: {test_dir}")

# 获取环境变量
home_dir = os.environ.get('HOME', '未设置')
# 获取HOME环境变量
print(f"HOME环境变量: {home_dir}")

# 设置环境变量
os.environ['TEST_VAR'] = 'test_value'
# 设置测试环境变量
test_var = os.environ.get('TEST_VAR')
# 获取测试环境变量
print(f"TEST_VAR环境变量: {test_var}")

2.2 sys模块 - 解释器访问 #

sys模块提供对Python解释器使用环境的访问，可以获取和修改解释器的不同部分。

属性/方法	含义与用法	作用举例/说明
sys.version	返回Python解释器的完整版本信息字符串。 示例： '3.10.6 (main, Nov 3 2022, 14:14:05) \n[GCC 11.3.0]'	用于调试、兼容性判断、诊断解释器环境。
sys.version_info	返回一个namedtuple，包含主版本、次版本和修订号等信息。 示例：sys.version_info(major=3, minor=10, micro=6, ...)	可分别通过.major、.minor、.micro获取对应数值。常用于代码版本兼容判断。 如：if sys.version_info >= (3, 6):
sys.argv	列表，保存命令行启动脚本时传递的参数。 sys.argv[0]为脚本本身文件名，后续为参数。	开发命令行工具或处理用户输入参数。
sys.platform	返回运行平台的标识字符串。 如： "win32"（Windows）、"linux"（Linux）、"darwin"（macOS）	用于区分不同平台执行不同逻辑。
sys.executable	返回Python解释器可执行文件路径。 如：/usr/bin/python3	脚本或子进程需要调用自身解释器时可用。
sys.path	列表，模块搜索路径。 解释器查找模块时依次扫描这些目录。	可动态添加自定义模块查找目录，常用于解决ModuleNotFoundError或扩展第三方库路径。
sys.getdefaultencoding()	返回当前Python默认字符串编码，通常为"utf-8"。	字符串与字节流编码转换时需要注意的环境参数。
sys.getfilesystemencoding()	返回操作系统文件系统编码，常为"utf-8"（类Unix）或"mbcs"（Windows）。	处理文件名、路径与字节数据的编码转换。

# 导入sys模块，用于访问解释器相关功能
import sys
# 导入platform模块，用于平台信息
import platform

# 获取Python解释器的版本信息
python_version = sys.version
# 打印Python版本
print(f"Python 版本: {python_version}")

# 获取Python版本号
version_info = sys.version_info
# 打印Python版本号
print(f"Python 版本号: {version_info.major}.{version_info.minor}.{version_info.micro}")

# 获取命令行参数列表
command_line_args = sys.argv
# 打印命令行参数
print(f"命令行参数: {command_line_args}")

# 获取平台信息
platform_name = sys.platform
# 打印平台名称
print(f"平台名称: {platform_name}")

# 获取Python可执行文件路径
executable_path = sys.executable
# 打印Python可执行文件路径
print(f"Python可执行文件路径: {executable_path}")

# 获取Python路径
python_path = sys.path
# 打印Python路径
print(f"Python路径: {python_path[:3]}...")  # 只显示前3个路径

# 获取默认编码
default_encoding = sys.getdefaultencoding()
# 打印默认编码
print(f"默认编码: {default_encoding}")

# 获取文件系统编码
filesystem_encoding = sys.getfilesystemencoding()
# 打印文件系统编码
print(f"文件系统编码: {filesystem_encoding}")

3. 数据处理模块 #

3.1 json模块 - JSON数据处理 #

json模块用于解析和生成JSON数据，常用于API请求和数据存储。

方法	作用	用法示例	说明与常见场景
json.dumps(obj)	将Python对象编码成JSON字符串	json_str = json.dumps({"a":1, "b":2})	将字典/列表等对象序列化为字符串，通常用于接口通信
json.loads(s)	将JSON字符串解码为Python对象	data = json.loads('{"x":100,"y":200}')	反序列化JSON文本为Python对象，常见于数据解析
json.dump(obj, fp)	将Python对象写入JSON文件	json.dump(dict, open('data.json','w'))	直接把对象写入文件，数据落盘或持久化
json.load(fp)	从文件读取JSON数据并转为Python对象	data = json.load(open('data.json'))	读取文件内容并自动转为Python对象，用于本地数据读取
json.JSONEncoder	自定义JSON编码行为	json.dumps(obj, cls=自定义Encoder)	处理不能被默认序列化的对象（如datetime等）
json.JSONDecoder	自定义JSON解码行为	json.loads(json_str, cls=自定义Decoder)	控制反序列化过程，特殊结构转为自定义对象
json.dumps(obj, ensure_ascii=False)	保证中文等非ASCII字符正确输出	json.dumps({"name": "中文"}, ensure_ascii=False)	输出中文友好显示，适合国际化和本地数据
json.dumps(obj, indent=4)	优化输出格式、美化JSON文本	json.dumps({"a":1,"b":2}, indent=4)	便于阅读或生成格式化文件，方便调试
json.dumps(obj, sort_keys=True)	按key排序	json.dumps({"b":2,"a":1}, sort_keys=True)	字典序输出，方便比较差异或保证可复现性

注：dumps和loads是Python对象与JSON字符串的相互转换；dump和load则直接针对文件对象操作。

# 导入json模块，用于JSON数据处理
import json
# 导入datetime模块，用于日期时间处理
from datetime import datetime

# 定义一个Python字典
data = {
    "name": "Alice",
    "age": 30,
    "isStudent": False,
    "courses": ["Math", "Science"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

# 将Python字典转换为JSON字符串
json_string = json.dumps(data, indent=4)
# 打印JSON字符串
print("Python字典转换为JSON字符串:")
print(json_string)

# 定义一个JSON字符串
json_data_string = '{"city": "New York", "population": 8000000}'
# 将JSON字符串解析为Python字典
parsed_data = json.loads(json_data_string)
# 打印解析后的Python字典
print("\nJSON字符串解析为Python字典:")
print(parsed_data)

# 处理包含日期的数据
data_with_date = {
    "name": "Bob",
    "birth_date": datetime(1990, 5, 15)
}

# 自定义JSON编码器处理日期
class DateTimeEncoder(json.JSONEncoder):
    # 定义一个自定义JSON编码器
    def default(self, obj):
        # 定义默认编码方法
        if isinstance(obj, datetime):
            # 如果对象是datetime类型
            return obj.isoformat()
            # 返回ISO格式的日期字符串
        return super().default(obj)
        # 调用父类的默认方法

# 使用自定义编码器
json_with_date = json.dumps(data_with_date, cls=DateTimeEncoder)
# 打印包含日期的JSON字符串
print("\n包含日期的JSON字符串:")
print(json_with_date)

# 从文件读取JSON数据
test_data = {"test": "data", "number": 42}
# 定义测试数据
with open('test.json', 'w') as f:
    # 打开文件进行写入
    json.dump(test_data, f)
    # 将数据写入文件

# 从文件读取JSON数据
with open('test.json', 'r') as f:
    # 打开文件进行读取
    loaded_data = json.load(f)
    # 从文件加载数据
    print(f"\n从文件加载的数据: {loaded_data}")

3.2 csv模块 - CSV文件处理 #

csv模块提供了对CSV文件操作的便捷接口，支持读取和写入CSV格式的数据。

方法/类	说明
csv.reader()	读取CSV文件，返回一个行迭代器。每行是一个列表。
csv.writer()	创建一个用于写入CSV文件的写入器对象。
csv.DictReader()	以字典形式读取CSV文件。每行是一个字典，键为表头。
csv.DictWriter()	以字典形式写入CSV文件。需要指定字段名。
csv.field_size_limit()	获取或设置字段最大字节数限制。
csv.register_dialect()	注册自定义CSV方言（分隔符、换行、引号等规则）。
csv.get_dialect()	获取已注册的方言对象。
csv.list_dialects()	列出所有已注册的方言名称。
writer.writerow(row)	向文件写入一行数据（列表或元组）。
writer.writerows(rows)	批量写入多行数据。
DictWriter.writeheader()	写入表头（字典的键）。
DictWriter.writerow(dict)	写入一行字典数据。
DictWriter.writerows(dicts)	批量写入多行字典数据。

常用方言参数包括：delimiter（分隔符）、quotechar（引号符号）、quoting（引用策略）、lineterminator（行结束符）等。

# 导入csv模块，用于CSV文件处理
import csv
# 导入os模块，用于文件操作
import os

# 定义CSV文件路径
csv_file_path = "example.csv"
# 设置CSV文件路径

# 写入CSV文件
with open(csv_file_path, 'w', newline='', encoding='utf-8') as file:
    # 打开CSV文件进行写入
    writer = csv.writer(file)
    # 创建CSV写入器
    # 写入表头
    writer.writerow(["Name", "Age", "City"])
    # 写入数据行
    writer.writerow(["Alice", 30, "New York"])
    writer.writerow(["Bob", 24, "London"])
    writer.writerow(["Charlie", 35, "Tokyo"])

# 打印CSV写入完成信息
print(f"CSV 文件 '{csv_file_path}' 写入完成。")

# 读取CSV文件
with open(csv_file_path, 'r', encoding='utf-8') as file:
    # 打开CSV文件进行读取
    reader = csv.reader(file)
    # 创建CSV读取器
    # 遍历并打印每一行
    print("\n读取 CSV 文件内容:")
    for row in reader:
        # 遍历每一行
        print(row)
        # 打印行内容

# 使用字典方式读取CSV文件
with open(csv_file_path, 'r', encoding='utf-8') as file:
    # 打开CSV文件进行读取
    dict_reader = csv.DictReader(file)
    # 创建CSV字典读取器
    print("\n使用字典方式读取 CSV 文件:")
    for row in dict_reader:
        # 遍历每一行
        print(f"姓名: {row['Name']}, 年龄: {row['Age']}, 城市: {row['City']}")
        # 打印行内容

# 清理测试文件
os.remove(csv_file_path)
# 删除测试文件
print(f"\n测试文件 '{csv_file_path}' 已删除")

4. 数学计算模块 #

4.1 math模块 - 数学函数 #

math模块提供标准数学函数，包括幂运算、对数、三角函数等。

方法/常量	作用简介	示例
math.sqrt(x)	求数字x的平方根	math.sqrt(16) 结果为 4.0
math.pow(x, y)	求x的y次幂（即x的y次方）	math.pow(2, 3) 结果为 8.0
math.pi	圆周率常量π	math.pi 结果约为 3.141592653589793
math.log(x)	求x的自然对数（以e为底）	math.log(10) 结果约为 2.3026
math.log10(x)	求x的以10为底的对数	math.log10(100) 结果为 2.0
math.sin(x)	求x弧度的正弦值（需使用math.radians	math.sin(math.radians(90)) 结果为 1.0
math.cos(x)	求x弧度的余弦值	math.cos(math.radians(60)) 结果为 0.5
math.tan(x)	求x弧度的正切值	math.tan(math.radians(45)) 结果约为 1.0
math.factorial(x)	求x的阶乘（x必须是非负整数）	math.factorial(5) 结果为 120
math.gcd(a, b)	求a和b的最大公约数	math.gcd(48, 18) 结果为 6
math.lcm(a, b)	求a和b的最小公倍数（Python 3.9+）	math.lcm(12, 18) 结果为 36

# 导入math模块，用于数学运算
import math
# 导入random模块，用于随机数生成
import random

# 计算平方根
sqrt_value = math.sqrt(16)
# 打印平方根
print(f"16的平方根: {sqrt_value}")

# 计算幂运算
power_value = math.pow(2, 3)
# 打印幂运算结果
print(f"2的3次方: {power_value}")

# 计算圆周率
pi_value = math.pi
# 打印圆周率
print(f"圆周率: {pi_value}")

# 计算自然对数
log_value = math.log(10)
# 打印自然对数
print(f"10的自然对数: {log_value}")

# 计算以10为底的对数
log10_value = math.log10(100)
# 打印以10为底的对数
print(f"100的以10为底的对数: {log10_value}")

# 计算正弦值
sin_value = math.sin(math.radians(90))
# 打印正弦值
print(f"90度的正弦值: {sin_value}")

# 计算余弦值
cos_value = math.cos(math.radians(60))
# 打印余弦值
print(f"60度的余弦值: {cos_value}")

# 计算正切值
tan_value = math.tan(math.radians(45))
# 打印正切值
print(f"45度的正切值: {tan_value}")

# 计算阶乘
factorial_value = math.factorial(5)
# 打印阶乘
print(f"5的阶乘: {factorial_value}")

# 计算最大公约数
gcd_value = math.gcd(48, 18)
# 打印最大公约数
print(f"48和18的最大公约数: {gcd_value}")

# 计算最小公倍数
lcm_value = math.lcm(12, 18)
# 打印最小公倍数
print(f"12和18的最小公倍数: {lcm_value}")

4.2 random模块 - 随机数生成 #

random模块用于生成随机数和随机选择，常用于模拟、游戏开发等场景。

方法	说明	示例
random.randint(a,b)	生成一个a到b之间的随机整数（包含a和b）	random.randint(1, 10)
random.uniform(a,b)	生成a到b之间的随机浮点数	random.uniform(1.0, 10.0)
random.choice(seq)	从序列（如列表、元组等）中随机选取一个元素	random.choice([1,2,3])
random.choices(seq, k=n)	从序列中随机选取n个元素（可重复）	random.choices(['a','b','c'], k=2)
random.sample(seq, n)	从序列中随机选取n个不同元素（不重复）	random.sample([1,2,3,4], 2)
random.shuffle(seq)	将序列中的元素随机排列（原地修改）	random.shuffle(my_list)
random.seed(n)	初始化随机数种子，保证可复现结果	random.seed(2024)

# 导入random模块，用于生成随机数和随机选择
import random
# 导入time模块，用于时间操作
import time

# 设置随机种子
random.seed(42)
# 设置随机种子为42

# 生成一个0到1之间的随机浮点数
random_float = random.random()
# 打印随机浮点数
print(f"随机浮点数 (0-1): {random_float}")

# 生成一个指定范围内的随机整数
random_int = random.randint(1, 10)
# 打印随机整数
print(f"随机整数 (1-10): {random_int}")

# 生成一个指定范围内的随机浮点数
random_uniform = random.uniform(1.0, 10.0)
# 打印随机浮点数
print(f"随机浮点数 (1.0-10.0): {random_uniform}")

# 从列表中随机选择一个元素
my_list = ["apple", "banana", "cherry", "date", "elderberry"]
# 定义列表
random_choice = random.choice(my_list)
# 打印随机选择的元素
print(f"随机选择的元素: {random_choice}")

# 从列表中随机选择多个元素
random_choices = random.choices(my_list, k=3)
# 打印随机选择的多个元素
print(f"随机选择的3个元素: {random_choices}")

# 从列表中随机选择多个不重复的元素
random_sample = random.sample(my_list, 3)
# 打印随机选择的不重复元素
print(f"随机选择的不重复元素: {random_sample}")

# 打乱列表顺序
shuffled_list = my_list.copy()
# 复制列表
random.shuffle(shuffled_list)
# 打乱列表顺序
print(f"打乱后的列表: {shuffled_list}")

# 生成正态分布的随机数
normal_random = random.normalvariate(0, 1)
# 打印正态分布随机数
print(f"正态分布随机数: {normal_random}")

# 生成指数分布的随机数
exp_random = random.expovariate(1.0)
# 打印指数分布随机数
print(f"指数分布随机数: {exp_random}")

# 生成随机字符串
import string
# 导入string模块
random_string = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
# 生成随机字符串
print(f"随机字符串: {random_string}")

5. 日期时间模块 #

datetime模块处理日期和时间，支持日期时间算术运算。

方法	说明	示例
datetime.now()	获取当前本地日期和时间	datetime.now()
datetime.today()	获取当前本地日期和时间（等价于now()）	datetime.today()
datetime.utcnow()	获取当前UTC日期和时间	datetime.utcnow()
datetime.fromtimestamp()	根据时间戳创建日期时间对象	datetime.fromtimestamp(1600000000)
datetime.strptime()	按指定格式解析日期字符串为datetime对象	datetime.strptime("2023-01-01", "%Y-%m-%d")
datetime.strftime()	按指定格式格式化datetime对象为字符串	now.strftime("%Y-%m-%d %H:%M:%S")
datetime.combine()	合并date和time为datetime对象	datetime.combine(date.today(), time.min)
datetime.replace()	替换datetime对象中的属性	now.replace(year=2025, month=12)
datetime.timetuple()	返回时间元组（time.struct_time）	now.timetuple()
datetime.timestamp()	返回时间戳（自1970年1月1日的秒数）	now.timestamp()
timedelta	两个datetime对象的差值，或用于时间运算	datetime.now() + timedelta(days=3)

# 导入datetime模块，用于日期和时间操作
from datetime import datetime, timedelta, date, time
# 导入timezone模块，用于时区处理
from datetime import timezone

# 获取当前日期和时间
now = datetime.now()
# 打印当前日期和时间
print(f"当前日期和时间: {now}")

# 获取当前日期
today = date.today()
# 打印当前日期
print(f"当前日期: {today}")

# 获取当前时间
current_time = datetime.now().time()
# 打印当前时间
print(f"当前时间: {current_time}")

# 创建一个特定的日期时间对象
specific_date = datetime(2023, 1, 1, 10, 30, 0)
# 打印特定日期时间
print(f"特定日期时间: {specific_date}")

# 计算未来7天后的日期
future_date = now + timedelta(days=7)
# 打印未来日期
print(f"7天后的日期: {future_date}")

# 计算过去30天前的日期
past_date = now - timedelta(days=30)
# 打印过去日期
print(f"30天前的日期: {past_date}")

# 计算时间差
time_diff = future_date - now
# 打印时间差
print(f"时间差: {time_diff}")
# 打印时间差的总秒数
print(f"时间差总秒数: {time_diff.total_seconds()}")

# 格式化日期时间
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
# 打印格式化日期时间
print(f"格式化日期时间: {formatted_date}")

# 解析日期时间字符串
date_string = "2023-12-25 15:30:00"
# 定义日期时间字符串
parsed_date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
# 解析日期时间字符串
print(f"解析的日期时间: {parsed_date}")

# 获取星期几
weekday = now.strftime("%A")
# 打印星期几
print(f"今天是: {weekday}")

# 获取月份名称
month_name = now.strftime("%B")
# 打印月份名称
print(f"当前月份: {month_name}")

# 计算两个日期之间的天数
date1 = date(2023, 1, 1)
# 定义第一个日期
date2 = date(2023, 12, 31)
# 定义第二个日期
days_between = (date2 - date1).days
# 计算两个日期之间的天数
print(f"2023年1月1日到12月31日之间的天数: {days_between}")

6. 文本处理模块 #

re模块用于处理正则表达式，支持复杂的字符串匹配和替换。

方法	说明	常用用途示例
re.match()	从字符串开头尝试匹配正则表达式	判断字符串是否符合特定模式
re.search()	在整个字符串中搜索第一个匹配	检查字符串内是否包括某个模式
re.findall()	查找所有匹配结果并以列表返回	提取字符串内所有目标子串
re.finditer()	查找所有匹配结果，返回迭代器	逐个处理匹配到的结果
re.sub()	替换字符串中匹配的内容	文本脱敏、批量替换
re.split()	按匹配的内容分割字符串	按特殊分隔符拆分字符串
re.compile()	编译正则表达式，生成正则对象	结合多次复用或复杂场景进行高效匹配

# 导入re模块，用于正则表达式操作
import re
# 导入string模块，用于字符串操作
import string

# 定义一个待搜索的字符串
text = "Hello, my email is test@example.com and another is user@domain.org."
# 定义一个正则表达式模式，用于匹配邮箱地址
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"

# 查找所有匹配的邮箱地址
emails = re.findall(pattern, text)
# 打印找到的邮箱地址
print(f"找到的邮箱: {emails}")

# 替换字符串中的所有数字为"#"
new_text = re.sub(r"\d", "#", "My phone number is 123-456-7890.")
# 打印替换后的字符串
print(f"替换数字后的文本: {new_text}")

# 使用match方法从字符串开头匹配
match_result = re.match(r"Hello", text)
# 打印匹配结果
if match_result:
    # 如果匹配成功
    print(f"匹配成功: {match_result.group()}")
    # 打印匹配的内容
else:
    # 如果匹配失败
    print("匹配失败")

# 使用search方法在字符串中搜索
search_result = re.search(r"email", text)
# 打印搜索结果
if search_result:
    # 如果搜索成功
    print(f"搜索成功: {search_result.group()}")
    # 打印搜索的内容
    print(f"搜索位置: {search_result.span()}")
    # 打印搜索位置
else:
    # 如果搜索失败
    print("搜索失败")

# 使用split方法分割字符串
split_result = re.split(r"[,.\s]+", text)
# 打印分割结果
print(f"分割结果: {split_result}")

# 使用compile方法预编译正则表达式
compiled_pattern = re.compile(r"\d+")
# 预编译正则表达式
numbers = compiled_pattern.findall("I have 5 apples and 3 oranges.")
# 使用预编译的正则表达式查找数字
print(f"找到的数字: {numbers}")

# 使用命名组
phone_pattern = r"(?P<area>\d{3})-(?P<exchange>\d{3})-(?P<number>\d{4})"
# 定义包含命名组的正则表达式
phone_text = "My phone number is 555-123-4567."
# 定义包含电话号码的文本
phone_match = re.search(phone_pattern, phone_text)
# 搜索电话号码
if phone_match:
    # 如果搜索成功
    print(f"区号: {phone_match.group('area')}")
    # 打印区号
    print(f"交换局: {phone_match.group('exchange')}")
    # 打印交换局
    print(f"号码: {phone_match.group('number')}")
    # 打印号码

# 使用零宽断言
lookahead_text = "apple123 banana456 cherry"
# 定义包含零宽断言的文本
lookahead_matches = re.findall(r"[a-zA-Z]+(?=\d+)", lookahead_text)
# 使用零宽先行断言匹配
print(f"零宽先行断言匹配: {lookahead_matches}")

# 使用零宽后行断言
lookbehind_text = "Price: $100, Cost: $50"
# 定义包含零宽后行断言的文本
lookbehind_matches = re.findall(r"(?<=\$)\d+", lookbehind_text)
# 使用零宽后行断言匹配
print(f"零宽后行断言匹配: {lookbehind_matches}")

7. 数据结构模块 #

collections模块提供了高级的数据结构，如namedtuple、deque、Counter等。

类/方法	说明
namedtuple	工厂函数，用于创建具名元组类型，类似轻量级的不可变类。
deque	双端队列，支持从队列两端高效地添加和删除元素。
appendleft()	在deque的左边（队首）添加一个元素。
append()	在deque的右边（队尾）添加一个元素。
Counter	计数器，统计可迭代对象中元素出现的次数，返回一个以元素为键、计数为值的字典。
defaultdict	带有默认值的字典，在访问不存在的键时会自动创建，默认值类型由初始化参数决定。
OrderedDict	有序字典，记录元素添加的顺序（Python 3.7+的内置dict也具备此功能，但OrderedDict有补充方法）。
ChainMap	将多个字典组合成一个视图进行统一查找，查询时会按照传入顺序依次查找。
UserDict	可继承的字典类，便于用户自定义字典行为。

# 导入namedtuple, deque, Counter, defaultdict, OrderedDict模块
from collections import namedtuple, deque, Counter, defaultdict, OrderedDict

# 导入itertools模块
import itertools

# 创建一个名为Point的具名元组，具有x和y两个字段
Point = namedtuple('Point', ['x', 'y'])

# 创建Point类型的实例，x为10，y为20
p = Point(10, 20)

# 打印Point具名元组及其x和y属性
print(f"具名元组 Point: {p}, x={p.x}, y={p.y}")

# 创建一个含有三个元素的双端队列
d = deque([1, 2, 3])

# 在双端队列的左边添加一个元素0
d.appendleft(0)

# 在双端队列的右边添加一个元素4
d.append(4)

# 打印当前双端队列的内容
print(f"双端队列 deque: {d}")

# 用Counter统计字符串"hello world"中每个字符出现的次数
word_counts = Counter("hello world")

# 打印统计结果
print(f"Counter 统计: {word_counts}")

# 创建一个值为list的defaultdict
dd = defaultdict(list)

# 在'fruits'这个key下添加'apple'
dd['fruits'].append('apple')

# 在'fruits'这个key下再添加'banana'
dd['fruits'].append('banana')

# 在'vegetables'这个key下添加'carrot'
dd['vegetables'].append('carrot')

# 打印整个defaultdict（转为普通dict后可读性更高）
print(f"默认字典: {dict(dd)}")

# 创建一个空的有序字典OrderedDict
od = OrderedDict()

# 在有序字典中添加键'first'，值为1
od['first'] = 1

# 在有序字典中添加键'second'，值为2
od['second'] = 2

# 在有序字典中添加键'third'，值为3
od['third'] = 3

# 打印有序字典的内容
print(f"有序字典: {od}")

# 导入ChainMap用于合并多个字典
from collections import ChainMap

# 定义第一个字典
dict1 = {'a': 1, 'b': 2}

# 定义第二个字典
dict2 = {'c': 3, 'd': 4}

# 定义第三个字典
dict3 = {'e': 5, 'f': 6}

# 使用ChainMap合并三个字典
chain = ChainMap(dict1, dict2, dict3)

# 打印合并后的链式映射（转为dict后仅展示第一个找到的key）
print(f"链式映射: {dict(chain)}")

# 导入UserDict用于自定义字典
from collections import UserDict

# 定义继承自UserDict的类，用于实现自定义字典逻辑
class MyDict(UserDict):

    # 重写__setitem__方法，使得设置的值都被乘以2后存储
    def __setitem__(self, key, value):
        super().__setitem__(key, value * 2)

# 创建MyDict类的实例
my_dict = MyDict()

# 给'my_dict'字典的'test'键赋值5，实际存储为10
my_dict['test'] = 5

# 打印自定义字典的内容
print(f"自定义字典: {my_dict}")

8. 函数工具模块 #

functools模块提供高阶函数和操作，如partial和lru_cache。

方法	作用	示例代码	主要用途
partial	固定部分函数参数，返回一个新的函数对象	double = partial(multiply, 2)	快速生成带部分默认参数的新函数，提高重用性
lru_cache	自动缓存函数结果，加速多次调用	@lru_cache(maxsize=None)	对递归、密集重复调用的函数加速
reduce	对序列连续累计调用某个二元函数，归约为单一结果	sum_result = reduce(lambda x, y: x + y, numbers)	实现序列的累积、求积等归并运算
wraps	装饰器工具，保留被装饰函数的元数据如__name__、__doc__等	@wraps(func)	保持被装饰函数的“身份”，便于调试和文档自动化

# 导入functools模块，提供高阶函数功能
from functools import partial, lru_cache, reduce, wraps
# 导入time模块，用于处理时间相关操作
import time

# 定义普通乘法函数
def multiply(a, b):
    return a * b

# 创建一个乘以2的偏函数
double = partial(multiply, 2)
# 调用偏函数，计算2*5
result_double = double(5)
# 输出偏函数计算结果
print(f"partial(multiply, 2)(5) 的结果: {result_double}")

# 使用lru_cache装饰器实现斐波那契数列带缓存提升递归效率
@lru_cache(maxsize=None)
def fibonacci(n):
    # 如果n小于2，直接返回n
    if n < 2:
        return n
    # 否则递归计算前两项之和
    return fibonacci(n-1) + fibonacci(n-2)

# 获取当前时间，记录斐波那契计算开始时间
start_time = time.time()
# 计算斐波那契数列第10项
fib_10 = fibonacci(10)
# 记录斐波那契计算结束时间
end_time = time.time()
# 输出第10项斐波那契数
print(f"fibonacci(10) 的结果: {fib_10}")
# 输出计算所消耗的时间
print(f"计算时间: {end_time - start_time:.6f} 秒")

# 定义一个列表用于累积操作
numbers = [1, 2, 3, 4, 5]
# 使用reduce函数累加列表所有元素
sum_result = reduce(lambda x, y: x + y, numbers)
# 输出累加的结果
print(f"reduce计算总和: {sum_result}")

# 使用reduce函数计算列表所有元素的乘积
product_result = reduce(lambda x, y: x * y, numbers)
# 输出乘积结果
print(f"reduce计算乘积: {product_result}")

# 定义装饰器，使用wraps保持原函数元信息
def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 打印被调用函数名
        print(f"调用函数: {func.__name__}")
        # 调用并返回原函数结果
        return func(*args, **kwargs)
    # 返回包装后的函数
    return wrapper

# 使用自定义装饰器修饰问候函数
@my_decorator
def greet(name):
    # 返回问候语字符串
    return f"Hello, {name}!"

# 调用加了装饰器的greet函数
result = greet("Alice")
# 输出问候语结果
print(f"问候结果: {result}")
# 输出函数名，验证wraps的作用
print(f"函数名: {greet.__name__}")

9.参考回答 #

9.1 开场 #

我经常使用Python标准库中的这些模块，按类别简要说明：

9.2 系统相关模块 #

os模块：用于文件和目录操作、环境变量获取、路径处理，常见场景是检查文件是否存在、创建目录、读取环境变量等。

sys模块：用于解释器信息、命令行参数、模块搜索路径，常见场景是处理命令行参数、版本判断、动态修改模块搜索路径等。

subprocess模块：用于执行系统命令、管理子进程，常见场景是批量自动化脚本、调用外部程序等。

9.3 数据处理模块 #

json模块：处理JSON序列化与反序列化，常见于Web API交互、配置文件读写、数据持久化等。

csv模块：读写CSV文件，常见于数据导入导出、Excel兼容处理、数据分析预处理等。

pickle模块：Python对象序列化，常见于缓存对象、模型保存等。

9.4 日期时间模块 #

datetime模块：日期时间处理，常见于日志时间戳、定时任务、日期计算、格式化与解析等。

time模块：时间戳与计时，常见于性能分析、延时等待、计时统计等。

9.5 数学计算模块 #

math模块：数学函数（平方根、幂运算、三角函数、对数等）和常量（如圆周率），常见于科学计算、统计与工程计算。

random模块：随机数生成与随机选择，常见于数据抽样、模拟、测试数据生成等。

9.6 文本处理模块 #

re模块：正则表达式，用于模式匹配、查找、替换、分割，常见于文本提取、数据清洗、格式校验等。

9.7 数据结构模块 #

collections模块：

• Counter：计数统计，快速统计元素频次
• deque：双端队列，高效的队列和栈操作
• defaultdict：默认值字典，避免键不存在时的判断
• namedtuple：具名元组，轻量级数据结构

itertools模块：迭代器工具，用于组合、排列、分组等，可优化性能并减少内存占用。

9.8 函数工具模块 #

functools模块：

• lru_cache：函数结果缓存，适用于递归或重复计算
• partial：偏函数，固定部分参数，提升代码复用
• wraps：保留装饰后函数的元信息

9.9 总结 #

这些模块覆盖了日常开发的常见需求：系统交互、数据处理、时间计算、文本处理、数据结构、函数工具等。我在实际项目中会根据需求灵活组合使用，它们在提升代码质量和开发效率上很有帮助。

使用建议

• 回答时长控制在3-5分钟
• 按类别组织，从系统相关开始
• 每个模块简述用途和典型场景
• 结合项目经验举例（如用json处理API、用os做文件管理等）
• 若被追问，可深入某个模块的具体方法或使用细节
• 保持自然、自信的表达节奏