Python 标准库

Python 标准库是 Python 语言的核心组成部分，提供了大量实用的模块和函数，涵盖了从文件操作到网络编程的各种功能。本章节将详细介绍 Python 标准库中常用的模块和它们的使用方法。

什么是标准库？

标准库是 Python 安装时默认包含的模块集合，不需要额外安装即可使用。这些模块由 Python 核心开发团队维护，提供了与操作系统、网络、文件系统等交互的功能。

常用标准库模块

1. 操作系统接口 - `os` 模块

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

主要功能：

文件和目录操作
环境变量管理
系统信息获取
进程管理

示例：

python

import os

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

# 列出目录内容
print("目录内容:")
for item in os.listdir("."):
    print(f"  - {item}")

# 创建目录
new_dir = "test_dir"
if not os.path.exists(new_dir):
    os.mkdir(new_dir)
    print(f"创建目录: {new_dir}")

# 检查文件是否存在
file_path = "example.txt"
print(f"文件 {file_path} 是否存在: {os.path.exists(file_path)}")

# 获取环境变量
print(f"PATH 环境变量: {os.getenv('PATH')}")

# 获取系统信息
print(f"操作系统名称: {os.name}")

# 删除目录
if os.path.exists(new_dir):
    os.rmdir(new_dir)
    print(f"删除目录: {new_dir}")

2. 文件路径操作 - `os.path` 模块

os.path 模块提供了路径操作相关的功能，用于处理文件路径。

主要功能：

路径拼接和分割
路径检查（是否存在、是否为文件/目录）
路径获取（目录名、文件名、扩展名）
文件属性获取（大小、修改时间）

示例：

python

import os.path
import time

# 路径操作
file_path = "example.txt"

# 获取绝对路径
abs_path = os.path.abspath(file_path)
print(f"绝对路径: {abs_path}")

# 获取目录名
dir_name = os.path.dirname(abs_path)
print(f"目录名: {dir_name}")

# 获取文件名
base_name = os.path.basename(abs_path)
print(f"文件名: {base_name}")

# 分割路径
dir_part, file_part = os.path.split(abs_path)
print(f"目录部分: {dir_part}")
print(f"文件部分: {file_part}")

# 分割扩展名
name_part, ext_part = os.path.splitext(base_name)
print(f"名称部分: {name_part}")
print(f"扩展名: {ext_part}")

# 路径拼接
new_path = os.path.join(dir_name, "subdir", "new_file.txt")
print(f"拼接路径: {new_path}")

# 检查路径
print(f"路径是否存在: {os.path.exists(abs_path)}")
print(f"是否为文件: {os.path.isfile(abs_path)}")
print(f"是否为目录: {os.path.isdir(abs_path)}")

# 文件属性
if os.path.isfile(abs_path):
    print(f"文件大小: {os.path.getsize(abs_path)} 字节")
    print(f"最后修改时间: {time.ctime(os.path.getmtime(abs_path))}")
    print(f"创建时间: {time.ctime(os.path.getctime(abs_path))}")

3. 数学函数 - `math` 模块

math 模块提供了数学运算相关的函数和常量。

主要功能：

基本数学函数（正弦、余弦、指数、对数等）
数学常量（π、e 等）
数值运算（取整、绝对值等）

示例：

python

import math

# 数学常量
print(f"π: {math.pi}")
print(f"e: {math.e}")
print(f"无穷大: {math.inf}")
print(f"NaN: {math.nan}")

# 基本数学函数
print(f"sin(π/2): {math.sin(math.pi/2)}")
print(f"cos(π): {math.cos(math.pi)}")
print(f"tan(π/4): {math.tan(math.pi/4)}")
print(f"asin(1): {math.asin(1)}")
print(f"acos(0): {math.acos(0)}")
print(f"atan(1): {math.atan(1)}")

# 指数和对数
print(f"e^2: {math.exp(2)}")
print(f"ln(e): {math.log(math.e)}")
print(f"log10(100): {math.log10(100)}")
print(f"2^3: {math.pow(2, 3)}")
print(f"√16: {math.sqrt(16)}")

# 数值运算
print(f"绝对值: {math.fabs(-5)}")
print(f"向上取整: {math.ceil(3.14)}")
print(f"向下取整: {math.floor(3.14)}")
print(f"四舍五入: {round(3.14159, 2)}")
print(f"整数部分和小数部分: {math.modf(3.14)}")
print(f"最大公约数: {math.gcd(12, 18)}")
print(f"阶乘: {math.factorial(5)}")

4. 随机数生成 - `random` 模块

random 模块提供了随机数生成相关的功能。

主要功能：

生成随机整数、浮点数
随机选择元素
随机打乱序列
设置随机种子

示例：

python

import random

# 设置随机种子（可重现结果）
random.seed(42)

# 生成随机浮点数（0-1）
print(f"随机浮点数: {random.random()}")

# 生成指定范围的随机浮点数
print(f"1-10 之间的随机浮点数: {random.uniform(1, 10)}")

# 生成指定范围的随机整数
print(f"1-10 之间的随机整数: {random.randint(1, 10)}")

# 生成指定步长的随机整数
print(f"0-10 之间步长为 2 的随机整数: {random.randrange(0, 10, 2)}")

# 随机选择元素
items = ["apple", "banana", "cherry", "date", "elderberry"]
print(f"随机选择一个元素: {random.choice(items)}")
print(f"随机选择 2 个元素: {random.sample(items, 2)}")

# 随机打乱序列
random.shuffle(items)
print(f"打乱后的序列: {items}")

# 加权随机选择
weights = [1, 2, 3, 2, 1]  # 权重
print(f"加权随机选择: {random.choices(items, weights=weights, k=3)}")

5. 日期和时间 - `datetime` 模块

datetime 模块提供了日期和时间处理相关的功能。

主要功能：

日期和时间对象
日期和时间运算
日期和时间格式化
时区处理

示例：

python

import datetime
import time

# 获取当前日期和时间
now = datetime.datetime.now()
print(f"当前日期和时间: {now}")
print(f"年: {now.year}")
print(f"月: {now.month}")
print(f"日: {now.day}")
print(f"时: {now.hour}")
print(f"分: {now.minute}")
print(f"秒: {now.second}")
print(f"微秒: {now.microsecond}")
print(f"星期几: {now.weekday()}")  # 0-6，0 表示周一

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

# 创建日期和时间对象
date_obj = datetime.date(2024, 1, 1)
print(f"创建的日期: {date_obj}")

time_obj = datetime.time(12, 30, 45)
print(f"创建的时间: {time_obj}")

datetime_obj = datetime.datetime(2024, 1, 1, 12, 30, 45)
print(f"创建的日期时间: {datetime_obj}")

# 日期和时间运算
tomorrow = today + datetime.timedelta(days=1)
print(f"明天: {tomorrow}")

next_week = today + datetime.timedelta(weeks=1)
print(f"下周: {next_week}")

# 日期差
diff = tomorrow - today
print(f"日期差: {diff}")
print(f"天数差: {diff.days}")

# 日期和时间格式化
print(f"格式化日期时间: {now.strftime('%Y-%m-%d %H:%M:%S')}")
print(f"格式化日期: {today.strftime('%Y-%m-%d')}")
print(f"格式化时间: {now.strftime('%H:%M:%S')}")
print(f"星期: {now.strftime('%A')}")
print(f"月份: {now.strftime('%B')}")

# 解析字符串为日期时间
str_date = "2024-01-01"
parsed_date = datetime.datetime.strptime(str_date, "%Y-%m-%d")
print(f"解析的日期: {parsed_date}")

# 时间戳转换
timestamp = time.time()
print(f"当前时间戳: {timestamp}")

from_timestamp = datetime.datetime.fromtimestamp(timestamp)
print(f"从时间戳转换: {from_timestamp}")

# UTC 时间
utc_now = datetime.datetime.utcnow()
print(f"UTC 时间: {utc_now}")

6. 字符串处理 - `string` 模块

string 模块提供了字符串处理相关的常量和函数。

主要功能：

字符串常量（大小写字母、数字、标点符号等）
字符串模板
字符串格式化

示例：

python

import string

# 字符串常量
print(f"大写字母: {string.ascii_uppercase}")
print(f"小写字母: {string.ascii_lowercase}")
print(f"大小写字母: {string.ascii_letters}")
print(f"数字: {string.digits}")
print(f"十六进制数字: {string.hexdigits}")
print(f"八进制数字: {string.octdigits}")
print(f"标点符号: {string.punctuation}")
print(f"空白字符: {repr(string.whitespace)}")

# 字符串模板
from string import Template

template = Template("Hello, $name! Today is $day.")
result = template.substitute(name="Alice", day="Monday")
print(f"模板替换: {result}")

# 安全替换（不会因缺少键而抛出异常）
template = Template("Hello, $name! Today is $day.")
result = template.safe_substitute(name="Alice")  # 缺少 day
print(f"安全替换: {result}")

# 自定义分隔符
class MyTemplate(Template):
    delimiter = "#"

template = MyTemplate("Hello, #name! Today is #day.")
result = template.substitute(name="Bob", day="Tuesday")
print(f"自定义分隔符: {result}")

7. 正则表达式 - `re` 模块

re 模块提供了正则表达式相关的功能，用于字符串匹配和处理。

主要功能：

正则表达式编译
字符串匹配
字符串替换
字符串分割

示例：

python

import re

# 正则表达式匹配
# 匹配邮箱地址
email_pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"

emails = ["user@example.com", "invalid-email", "another.user@domain.co.uk"]

for email in emails:
    if re.match(email_pattern, email):
        print(f"{email} 是有效的邮箱地址")
    else:
        print(f"{email} 不是有效的邮箱地址")

# 匹配电话号码（中国手机号）
phone_pattern = r"1[3-9]\d{9}"

phones = ["13812345678", "12345678901", "18887654321"]

for phone in phones:
    if re.match(phone_pattern, phone):
        print(f"{phone} 是有效的手机号")
    else:
        print(f"{phone} 不是有效的手机号")

# 字符串替换
text = "Hello, World! Hello, Python!"

# 替换所有 "Hello" 为 "Hi"
result = re.sub(r"Hello", "Hi", text)
print(f"替换后: {result}")

# 替换指定次数
result = re.sub(r"Hello", "Hi", text, count=1)
print(f"替换一次: {result}")

# 使用函数进行替换
def replace_func(match):
    return match.group(0).upper()

result = re.sub(r"Hello", replace_func, text)
print(f"使用函数替换: {result}")

# 字符串分割
text = "apple, banana; cherry|date"

# 使用正则表达式分割
result = re.split(r"[,;|]", text)
print(f"分割结果: {result}")

# 分割并去除空白
result = [item.strip() for item in re.split(r"[,;|]", text)]
print(f"分割并去除空白: {result}")

# 捕获组
pattern = r"(\d{4})-(\d{2})-(\d{2})"
date_str = "2024-01-01"

match = re.match(pattern, date_str)
if match:
    print(f"完整匹配: {match.group(0)}")
    print(f"年: {match.group(1)}")
    print(f"月: {match.group(2)}")
    print(f"日: {match.group(3)}")

# 编译正则表达式（提高性能）
compiled_pattern = re.compile(r"\b\w+@\w+\.\w+\b")
text = "Contact us at support@example.com or info@company.org"

matches = compiled_pattern.findall(text)
print(f"找到的邮箱: {matches}")

# 查找所有匹配
for match in compiled_pattern.finditer(text):
    print(f"邮箱: {match.group(0)}, 位置: {match.span()}")

8. 数据结构 - `collections` 模块

collections 模块提供了额外的数据结构，扩展了 Python 的内置数据类型。

主要功能：

计数器（Counter）
有序字典（OrderedDict）
默认字典（defaultdict）
双向队列（deque）
命名元组（namedtuple）

示例：

python

import collections

# 计数器（Counter）
from collections import Counter

# 统计字符串中字符出现的次数
text = "hello world"
counter = Counter(text)
print(f"字符计数: {counter}")
print(f"出现最多的 2 个字符: {counter.most_common(2)}")

# 统计列表中元素出现的次数
fruits = ["apple", "banana", "cherry", "apple", "banana", "apple"]
fruit_counter = Counter(fruits)
print(f"水果计数: {fruit_counter}")

# 计数器运算
counter1 = Counter(a=3, b=1)
counter2 = Counter(a=1, b=2)
print(f"counter1 + counter2: {counter1 + counter2}")
print(f"counter1 - counter2: {counter1 - counter2}")
print(f"counter1 & counter2: {counter1 & counter2}")  # 交集
print(f"counter1 | counter2: {counter1 | counter2}")  # 并集

# 默认字典（defaultdict）
from collections import defaultdict

# 创建默认值为列表的字典
word_dict = defaultdict(list)
sentence = "the quick brown fox jumps over the lazy dog"

for word in sentence.split():
    first_letter = word[0]
    word_dict[first_letter].append(word)

print(f"按首字母分组: {dict(word_dict)}")

# 创建默认值为整数的字典
count_dict = defaultdict(int)
for word in sentence.split():
    count_dict[word] += 1

print(f"单词计数: {dict(count_dict)}")

# 双向队列（deque）
from collections import deque

# 创建双向队列
dq = deque([1, 2, 3])
print(f"初始双向队列: {dq}")

# 添加元素
dq.append(4)  # 右侧添加
print(f"右侧添加后: {dq}")

dq.appendleft(0)  # 左侧添加
print(f"左侧添加后: {dq}")

# 删除元素
popped_right = dq.pop()  # 右侧删除
print(f"右侧弹出: {popped_right}")
print(f"右侧弹出后: {dq}")

popped_left = dq.popleft()  # 左侧删除
print(f"左侧弹出: {popped_left}")
print(f"左侧弹出后: {dq}")

# 旋转
dq.rotate(1)  # 向右旋转 1 位
print(f"向右旋转 1 位: {dq}")

dq.rotate(-1)  # 向左旋转 1 位
print(f"向左旋转 1 位: {dq}")

# 命名元组（namedtuple）
from collections import namedtuple

# 创建命名元组类
Person = namedtuple('Person', ['name', 'age', 'city'])

# 创建命名元组实例
person = Person('Alice', 30, 'New York')
print(f"命名元组: {person}")
print(f"姓名: {person.name}")
print(f"年龄: {person.age}")
print(f"城市: {person.city}")

# 通过索引访问
print(f"通过索引访问: {person[0]}")

# 转换为字典
print(f"转换为字典: {person._asdict()}")

# 替换字段值（返回新实例）
new_person = person._replace(age=31, city='Boston')
print(f"替换后的命名元组: {new_person}")
print(f"原始命名元组: {person}")

# 有序字典（OrderedDict）- Python 3.7+ 中普通字典已保持插入顺序
from collections import OrderedDict

# 创建有序字典
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(f"有序字典: {od}")

# 删除和重新插入元素
od.pop('b')
print(f"删除 'b' 后: {od}")
od['b'] = 4
print(f"重新插入 'b' 后: {od}")

# 移动元素到末尾
od.move_to_end('a')
print(f"移动 'a' 到末尾: {od}")

# 移动元素到开头
od.move_to_end('b', last=False)
print(f"移动 'b' 到开头: {od}")

9. 迭代器工具 - `itertools` 模块

itertools 模块提供了用于创建和操作迭代器的工具函数。

主要功能：

无限迭代器
迭代器组合
迭代器过滤
迭代器分组

示例：

python

import itertools

# 无限迭代器
# count: 从指定值开始计数
print("count 迭代器:")
for i, num in enumerate(itertools.count(10, 2)):
    print(num, end=" ")
    if i >= 4:
        break
print()

# cycle: 循环迭代序列
print("cycle 迭代器:")
colors = ['red', 'green', 'blue']
for i, color in enumerate(itertools.cycle(colors)):
    print(color, end=" ")
    if i >= 8:
        break
print()

# repeat: 重复一个值
print("repeat 迭代器:")
for item in itertools.repeat('hello', 3):
    print(item)

# 迭代器组合
# chain: 连接多个迭代器
print("chain 迭代器:")
lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for item in itertools.chain(*lists):
    print(item, end=" ")
print()

# zip_longest: 类似于 zip，但会填充缺失值
print("zip_longest 迭代器:")
a = [1, 2, 3]
b = ['a', 'b']
for item in itertools.zip_longest(a, b, fillvalue='-'):
    print(item)

# product: 笛卡尔积
print("product 迭代器:")
colors = ['red', 'green']
sizes = ['S', 'M', 'L']
for item in itertools.product(colors, sizes):
    print(item)

# permutations: 排列
print("permutations 迭代器:")
for item in itertools.permutations(['a', 'b', 'c'], 2):
    print(item)

# combinations: 组合
print("combinations 迭代器:")
for item in itertools.combinations(['a', 'b', 'c'], 2):
    print(item)

# combinations_with_replacement: 带重复的组合
print("combinations_with_replacement 迭代器:")
for item in itertools.combinations_with_replacement(['a', 'b', 'c'], 2):
    print(item)

# 迭代器过滤
# filterfalse: 过滤掉满足条件的元素
print("filterfalse 迭代器:")
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for item in itertools.filterfalse(lambda x: x % 2 == 0, numbers):
    print(item, end=" ")
print()

# takewhile: 只要条件为真就取元素
print("takewhile 迭代器:")
for item in itertools.takewhile(lambda x: x < 5, numbers):
    print(item, end=" ")
print()

# dropwhile: 丢弃满足条件的元素，然后取剩余元素
print("dropwhile 迭代器:")
for item in itertools.dropwhile(lambda x: x < 5, numbers):
    print(item, end=" ")
print()

# compress: 根据选择器过滤元素
print("compress 迭代器:")
data = ['a', 'b', 'c', 'd', 'e']
selectors = [True, False, True, False, True]
for item in itertools.compress(data, selectors):
    print(item, end=" ")
print()

# 迭代器分组
# groupby: 分组连续的相同元素
print("groupby 迭代器:")
data = ['a', 'a', 'b', 'b', 'b', 'c', 'a', 'a']
for key, group in itertools.groupby(data):
    print(f"{key}: {list(group)}")

# 按长度分组
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
for key, group in itertools.groupby(sorted(words, key=len), key=len):
    print(f"长度 {key}: {list(group)}")

10. 文件和目录操作 - `shutil` 模块

shutil 模块提供了高级文件和目录操作功能，是 os 模块的补充。

主要功能：

文件复制
目录复制
文件移动和重命名
目录删除
文件权限管理

示例：

python

import shutil
import os

# 文件复制
# 复制文件
shutil.copy('example.txt', 'example_copy.txt')
print("文件复制成功")

# 复制文件和权限
shutil.copy2('example.txt', 'example_copy2.txt')
print("文件和权限复制成功")

# 复制整个目录树
if not os.path.exists('copy_dir'):
    os.makedirs('copy_dir')
shutil.copytree('.', 'copy_dir/example_files', ignore=shutil.ignore_patterns('*.pyc', '__pycache__'))
print("目录树复制成功")

# 文件移动和重命名
# 移动文件
shutil.move('example_copy.txt', 'moved_example.txt')
print("文件移动成功")

# 重命名文件
shutil.move('moved_example.txt', 'renamed_example.txt')
print("文件重命名成功")

# 目录删除
# 删除整个目录树
if os.path.exists('copy_dir'):
    shutil.rmtree('copy_dir')
    print("目录树删除成功")

# 文件权限管理
# 获取文件权限
import stat

file_stat = os.stat('example.txt')
print(f"文件权限: {oct(file_stat.st_mode)[-3:]}")

# 更改文件权限
os.chmod('example.txt', stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH)
print("文件权限更改成功")

# 归档操作
# 创建压缩文件
shutil.make_archive('archive', 'zip', '.', 'example.txt')
print("压缩文件创建成功")

# 解压文件
shutil.unpack_archive('archive.zip', 'extracted')
print("压缩文件解压成功")

# 清理
for file in ['example_copy2.txt', 'renamed_example.txt', 'archive.zip']:
    if os.path.exists(file):
        os.remove(file)
        print(f"删除文件: {file}")

if os.path.exists('extracted'):
    shutil.rmtree('extracted')
    print("删除目录: extracted")

11. 网络编程 - `socket` 模块

socket 模块提供了网络编程相关的功能，用于创建网络连接和通信。

主要功能：

创建套接字
网络连接
数据发送和接收
网络地址解析

示例：

python

import socket

# 创建 TCP 服务器
import threading

def handle_client(client_socket):
    """处理客户端连接"""
    try:
        # 接收数据
        data = client_socket.recv(1024)
        print(f"收到数据: {data.decode('utf-8')}")
        
        # 发送响应
        response = "Hello, Client!"
        client_socket.sendall(response.encode('utf-8'))
    finally:
        # 关闭连接
        client_socket.close()

def start_server():
    """启动服务器"""
    # 创建 TCP 套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 设置端口复用
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    # 绑定地址和端口
    server_socket.bind(('localhost', 8080))
    
    # 开始监听
    server_socket.listen(5)
    print("服务器启动，监听端口 8080")
    
    try:
        while True:
            # 接受连接
            client_socket, client_address = server_socket.accept()
            print(f"接受到来自 {client_address} 的连接")
            
            # 创建线程处理客户端
            client_thread = threading.Thread(target=handle_client, args=(client_socket,))
            client_thread.start()
    finally:
        # 关闭服务器
        server_socket.close()

# 创建 TCP 客户端
def start_client():
    """启动客户端"""
    # 创建 TCP 套接字
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    try:
        # 连接服务器
        client_socket.connect(('localhost', 8080))
        print("连接服务器成功")
        
        # 发送数据
        message = "Hello, Server!"
        client_socket.sendall(message.encode('utf-8'))
        print(f"发送数据: {message}")
        
        # 接收响应
        data = client_socket.recv(1024)
        print(f"收到响应: {data.decode('utf-8')}")
    finally:
        # 关闭连接
        client_socket.close()

# 测试服务器和客户端
if __name__ == "__main__":
    # 启动服务器线程
    server_thread = threading.Thread(target=start_server)
    server_thread.daemon = True
    server_thread.start()
    
    # 等待服务器启动
    import time
    time.sleep(1)
    
    # 启动客户端
    start_client()
    
    # 等待客户端完成
    time.sleep(1)

12. HTTP 客户端 - `urllib` 模块

urllib 模块提供了 HTTP 客户端功能，用于发送 HTTP 请求和处理响应。

主要功能：

HTTP 请求发送
URL 解析
响应处理
异常处理

示例：

python

import urllib.request
import urllib.parse
import urllib.error

# 发送 GET 请求
print("发送 GET 请求:")
try:
    # 发送请求
    response = urllib.request.urlopen('https://api.github.com/users/octocat')
    
    # 读取响应
    data = response.read()
    print(f"响应状态码: {response.status}")
    print(f"响应头: {response.getheaders()}")
    print(f"响应内容: {data.decode('utf-8')}")
except urllib.error.URLError as e:
    print(f"URL 错误: {e}")
except urllib.error.HTTPError as e:
    print(f"HTTP 错误: {e.code} - {e.reason}")

# 发送 POST 请求
print("\n发送 POST 请求:")
try:
    # 准备数据
    data = urllib.parse.urlencode({'name': 'Alice', 'age': 30}).encode('utf-8')
    
    # 创建请求
    req = urllib.request.Request('https://httpbin.org/post', data=data, method='POST')
    req.add_header('Content-Type', 'application/x-www-form-urlencoded')
    
    # 发送请求
    response = urllib.request.urlopen(req)
    
    # 读取响应
    data = response.read()
    print(f"响应状态码: {response.status}")
    print(f"响应内容: {data.decode('utf-8')}")
except urllib.error.URLError as e:
    print(f"URL 错误: {e}")
except urllib.error.HTTPError as e:
    print(f"HTTP 错误: {e.code} - {e.reason}")

# URL 解析
print("\nURL 解析:")
url = 'https://www.example.com:8080/path/to/page?name=Alice&age=30#section1'

# 解析 URL
parsed_url = urllib.parse.urlparse(url)
print(f"协议: {parsed_url.scheme}")
print(f"域名: {parsed_url.netloc}")
print(f"路径: {parsed_url.path}")
print(f"查询参数: {parsed_url.query}")
print(f"片段: {parsed_url.fragment}")

# 解析查询参数
query_params = urllib.parse.parse_qs(parsed_url.query)
print(f"解析后的查询参数: {query_params}")

# 构建 URL
new_params = {'name': 'Bob', 'age': 25}
encoded_params = urllib.parse.urlencode(new_params)
new_url = urllib.parse.urlunparse((parsed_url.scheme, parsed_url.netloc, parsed_url.path, '', encoded_params, ''))
print(f"构建的新 URL: {new_url}")

# 使用代理
print("\n使用代理:")
try:
    # 创建代理处理器
    proxy_handler = urllib.request.ProxyHandler({'http': 'http://proxy.example.com:8080'})
    opener = urllib.request.build_opener(proxy_handler)
    
    # 发送请求
    response = opener.open('https://httpbin.org/ip')
    data = response.read()
    print(f"响应内容: {data.decode('utf-8')}")
except urllib.error.URLError as e:
    print(f"URL 错误: {e}")

标准库的最佳实践

1. 熟悉常用模块

熟悉 Python 标准库中的常用模块，如 os、sys、datetime、re 等，可以提高开发效率。

2. 查阅官方文档

Python 官方文档对标准库有详细的说明，遇到问题时可以查阅：Python 标准库文档

3. 使用 `dir()` 和 `help()` 函数

使用 dir() 函数查看模块的属性和方法，使用 help() 函数查看详细说明：

python

import os
print(dir(os))  # 查看 os 模块的属性和方法
print(help(os.path.exists))  # 查看 os.path.exists 函数的说明

4. 合理使用标准库

标准库提供了很多功能，但并不是所有功能都需要使用。根据具体需求选择合适的模块和函数。

5. 注意版本兼容性

不同版本的 Python 标准库可能有差异，编写代码时要注意版本兼容性。

总结

Python 标准库是 Python 语言的重要组成部分，提供了丰富的功能模块，涵盖了从文件操作到网络编程的各种场景。本章节介绍了：

操作系统接口：os 和 os.path 模块
数学函数：math 模块
随机数生成：random 模块
日期和时间：datetime 模块
字符串处理：string 模块
正则表达式：re 模块
数据结构：collections 模块
迭代器工具：itertools 模块
文件和目录操作：shutil 模块
网络编程：socket 模块
HTTP 客户端：urllib 模块

掌握这些标准库模块的使用方法，可以大大提高 Python 编程效率，减少重复代码的编写。在实际开发中，应该根据具体需求选择合适的标准库模块，并结合第三方库来完成更复杂的任务。

Python 标准库 ​

什么是标准库？ ​

常用标准库模块 ​

1. 操作系统接口 - os 模块 ​

2. 文件路径操作 - os.path 模块 ​

3. 数学函数 - math 模块 ​

4. 随机数生成 - random 模块 ​

5. 日期和时间 - datetime 模块 ​

6. 字符串处理 - string 模块 ​

7. 正则表达式 - re 模块 ​

8. 数据结构 - collections 模块 ​

9. 迭代器工具 - itertools 模块 ​

10. 文件和目录操作 - shutil 模块 ​

11. 网络编程 - socket 模块 ​

12. HTTP 客户端 - urllib 模块 ​

标准库的最佳实践 ​

1. 熟悉常用模块 ​

2. 查阅官方文档 ​

3. 使用 dir() 和 help() 函数 ​

4. 合理使用标准库 ​

5. 注意版本兼容性 ​

总结 ​

Python 标准库

什么是标准库？

常用标准库模块

1. 操作系统接口 - `os` 模块

2. 文件路径操作 - `os.path` 模块

3. 数学函数 - `math` 模块

4. 随机数生成 - `random` 模块

5. 日期和时间 - `datetime` 模块

6. 字符串处理 - `string` 模块

7. 正则表达式 - `re` 模块

8. 数据结构 - `collections` 模块

9. 迭代器工具 - `itertools` 模块

10. 文件和目录操作 - `shutil` 模块

11. 网络编程 - `socket` 模块

12. HTTP 客户端 - `urllib` 模块

标准库的最佳实践

1. 熟悉常用模块

2. 查阅官方文档

3. 使用 `dir()` 和 `help()` 函数

4. 合理使用标准库

5. 注意版本兼容性

总结