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

# 导入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}")

# 导入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}")

# 导入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}")

# 导入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}' 已删除")

# 导入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}")

# 导入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}")

# 导入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}")

# 导入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}")

# 导入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}")

# 导入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__}")