Python标准库详解

1. 概述

Python标准库（Python Standard Library）是Python发行版中包含的一系列模块和包，提供了丰富的功能，涵盖了从基本操作到高级应用的各个方面。

1.1 标准库的重要性

标准库是Python的核心优势之一，它：

• 提供了Python语言的基础功能扩展
• 避免了重复造轮子，提高开发效率
• 经过严格测试，质量可靠
• 与Python解释器紧密集成，性能优化
• 跨平台兼容，支持Windows、Linux、macOS等

1.2 标准库的分类

Python标准库可以分为以下几大类：

2. 核心功能模块

2.1 文本处理

2.1.1 string模块

提供字符串操作的常量和辅助函数：

import string

# 字符串常量
print(string.ascii_letters)  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.digits)  # 0123456789
print(string.punctuation)  # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

# 格式化字符串
template = string.Template("Hello, $name!")
print(template.substitute(name="Zhang San"))  # Hello, Zhang San!

2.1.2 re模块

提供正则表达式支持：

import re

# 匹配字符串
pattern = r"\d+"  # 匹配一个或多个数字
result = re.search(pattern, "Age: 25")
print(result.group())  # 25

# 替换字符串
text = "Hello 123 world 456"
new_text = re.sub(r"\d+", "***", text)
print(new_text)  # Hello *** world ***

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

2.1.3 textwrap模块

提供文本格式化功能：

import textwrap

# 包装长文本
long_text = "This is a very long text that needs to be wrapped into multiple lines for better readability."
wrapped_text = textwrap.fill(long_text, width=30)
print(wrapped_text)
# This is a very long text that
# needs to be wrapped into multiple
# lines for better readability.

# 缩进文本
indented_text = textwrap.indent(long_text, "  ")
print(indented_text)
#   This is a very long text that needs to be wrapped into multiple lines for better readability.

2.2 文件和目录操作

2.2.1 os模块

提供与操作系统交互的功能：

import os

# 获取当前工作目录
print(os.getcwd())  # 获取当前工作目录

# 列出目录内容
print(os.listdir("."))  # 列出当前目录内容

# 创建目录
os.makedirs("new_dir", exist_ok=True)  # 创建目录，exist_ok=True表示目录已存在时不报错

# 删除文件和目录
os.remove("file.txt")  # 删除文件
os.rmdir("empty_dir")  # 删除空目录

# 重命名文件或目录
os.rename("old_name.txt", "new_name.txt")

# 获取文件属性
print(os.stat("file.txt"))  # 获取文件状态信息

2.2.2 pathlib模块

提供面向对象的路径操作（Python 3.4+）：

from pathlib import Path

# 创建Path对象
path = Path("./new_dir/file.txt")

# 检查路径是否存在
print(path.exists())  # 检查路径是否存在

# 创建目录
path.parent.mkdir(parents=True, exist_ok=True)  # 创建父目录，parents=True表示创建所有必要的父目录

# 写入文件
path.write_text("Hello, World!")

# 读取文件
print(path.read_text())  # Hello, World!

# 获取文件名和扩展名
print(path.name)  # file.txt
print(path.stem)  # file
print(path.suffix)  # .txt

# 获取绝对路径
print(path.absolute())  # 获取绝对路径

2.2.3 shutil模块

提供高级文件和目录操作：

import shutil

# 复制文件
shutil.copy("source.txt", "destination.txt")  # 复制文件内容和权限
shutil.copy2("source.txt", "destination.txt")  # 复制文件内容、权限和元数据

# 复制目录
shutil.copytree("source_dir", "destination_dir")  # 复制整个目录树

# 移动文件或目录
shutil.move("source.txt", "new_location/")  # 移动文件

# 删除目录树
shutil.rmtree("dir_to_delete")  # 递归删除目录树

# 压缩文件
shutil.make_archive("archive", "zip", "dir_to_archive")  # 创建zip压缩文件

# 解压文件
shutil.unpack_archive("archive.zip", "destination_dir")  # 解压zip文件

2.3 数据结构

2.3.1 collections模块

提供扩展的数据结构：

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

# Counter：计数
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
count = Counter(words)
print(count)  # Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print(count.most_common(2))  # [('apple', 3), ('banana', 2)]

# defaultdict：带默认值的字典
d = defaultdict(int)  # 默认值为0
d["a"] += 1
d["b"] += 2
print(d)  # defaultdict(<class 'int'>, {'a': 1, 'b': 2})

# deque：双端队列
q = deque([1, 2, 3])
q.append(4)  # 右侧添加
q.appendleft(0)  # 左侧添加
print(q)  # deque([0, 1, 2, 3, 4])
q.pop()  # 右侧删除
q.popleft()  # 左侧删除
print(q)  # deque([1, 2, 3])

# namedtuple：命名元组
Person = namedtuple("Person", ["name", "age"])
p = Person("Zhang San", 30)
print(p.name)  # Zhang San
print(p.age)  # 30
print(p)  # Person(name='Zhang San', age=30)

# OrderedDict：有序字典（Python 3.7+中普通字典也有序）
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3
print(od)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

2.3.2 heapq模块

提供堆队列算法（优先队列）：

import heapq

# 创建最小堆
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 4)
heapq.heappush(heap, 1)
heapq.heappush(heap, 5)
print(heap)  # [1, 1, 4, 3, 5]

# 弹出最小元素
print(heapq.heappop(heap))  # 1
print(heapq.heappop(heap))  # 1
print(heap)  # [3, 5, 4]

# 获取前n个最大元素
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(heapq.nlargest(3, numbers))  # [9, 6, 5]

# 获取前n个最小元素
print(heapq.nsmallest(3, numbers))  # [1, 1, 2]

2.3.3 bisect模块

提供二分查找算法：

import bisect

# 有序列表
numbers = [1, 3, 5, 7, 9]

# 查找插入位置
print(bisect.bisect(numbers, 4))  # 2
print(bisect.bisect(numbers, 5))  # 3

# 插入元素（保持有序）
bisect.insort(numbers, 4)
print(numbers)  # [1, 3, 4, 5, 7, 9]
bisect.insort(numbers, 6)
print(numbers)  # [1, 3, 4, 5, 6, 7, 9]

# 左侧和右侧插入
print(bisect.bisect_left(numbers, 5))  # 3
print(bisect.bisect_right(numbers, 5))  # 4

2.4 网络编程

2.4.1 socket模块

提供低级网络通信功能：

import socket

# 创建TCP客户端
def tcp_client():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(("www.example.com", 80))  # 连接到服务器
    client.sendall(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")  # 发送HTTP请求
    response = client.recv(1024)  # 接收响应
    print(response.decode())  # 解码并打印响应
    client.close()  # 关闭连接

# 创建TCP服务器
def tcp_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("localhost", 8888))  # 绑定到本地端口8888
    server.listen(5)  # 开始监听，最大连接数5
    print("Server listening on port 8888...")
    
    while True:
        client, addr = server.accept()  # 接受客户端连接
        print(f"Connection from {addr}")
        client.sendall(b"Hello, Client!")  # 发送消息
        client.close()  # 关闭连接

2.4.2 urllib模块

提供高级网络请求功能：

from urllib.request import urlopen, Request
from urllib.parse import urlencode

# 发送GET请求
with urlopen("https://www.example.com") as response:
    html = response.read().decode()
    print(html[:100])  # 打印前100个字符

# 发送POST请求
data = urlencode({"key": "value"}).encode()
request = Request("https://httpbin.org/post", data=data)
with urlopen(request) as response:
    result = response.read().decode()
    print(result)

# 下载文件
from urllib.request import urlretrieve
urlretrieve("https://www.example.com/image.jpg", "image.jpg")  # 下载文件到本地

2.4.3 http模块

提供HTTP协议相关功能：

from http.server import HTTPServer, BaseHTTPRequestHandler

# 创建简单的HTTP服务器
class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)  # 发送200 OK响应
        self.send_header("Content-type", "text/html")  # 设置Content-type
        self.end_headers()  # 结束响应头
        self.wfile.write(b"<html><body><h1>Hello, World!</h1></body></html>")  # 发送响应内容

def run_server():
    server_address = ("", 8000)  # 监听所有接口的8000端口
    httpd = HTTPServer(server_address, MyHandler)
    print("Server running on port 8000...")
    httpd.serve_forever()  # 开始服务器

2.5 并发编程

2.5.1 threading模块

提供多线程支持：

import threading
import time

# 线程函数
def thread_function(name):
    print(f"Thread {name}: starting")
    time.sleep(2)
    print(f"Thread {name}: finishing")

# 创建线程
threads = []
for i in range(3):
    t = threading.Thread(target=thread_function, args=(i,))
    threads.append(t)
    t.start()  # 启动线程

# 等待所有线程完成
for t in threads:
    t.join()

print("All threads finished")

2.5.2 multiprocessing模块

提供多进程支持：

import multiprocessing
import time

# 进程函数
def process_function(name):
    print(f"Process {name}: starting")
    time.sleep(2)
    print(f"Process {name}: finishing")

# 创建进程
processes = []
for i in range(3):
    p = multiprocessing.Process(target=process_function, args=(i,))
    processes.append(p)
    p.start()  # 启动进程

# 等待所有进程完成
for p in processes:
    p.join()

print("All processes finished")

2.5.3 asyncio模块

提供异步IO支持（Python 3.4+）：

import asyncio

# 异步函数
async def async_function(name):
    print(f"Coroutine {name}: starting")
    await asyncio.sleep(2)  # 模拟IO操作
    print(f"Coroutine {name}: finishing")
    return f"Result from {name}"

# 主函数
async def main():
    # 创建多个协程任务
    tasks = [
        asyncio.create_task(async_function(1)),
        asyncio.create_task(async_function(2)),
        asyncio.create_task(async_function(3))
    ]
    
    # 等待所有任务完成
    results = await asyncio.gather(*tasks)
    print(results)

# 运行主函数
asyncio.run(main())

2.6 数学计算

2.6.1 math模块

提供数学函数：

import math

# 基本数学函数
print(math.sqrt(16))  # 4.0 平方根
print(math.pow(2, 3))  # 8.0 幂运算
print(math.exp(1))  # 2.718281828459045 自然指数
print(math.log(2))  # 0.6931471805599453 自然对数

# 三角函数
print(math.sin(math.pi/2))  # 1.0 正弦
print(math.cos(math.pi))  # -1.0 余弦
print(math.tan(math.pi/4))  # 0.9999999999999999 正切

# 常数
print(math.pi)  # 3.141592653589793 π
print(math.e)  # 2.718281828459045 e
print(math.inf)  # 无穷大
print(math.nan)  # 非数字

2.6.2 random模块

提供随机数生成功能：

import random

# 生成随机整数
print(random.randint(1, 10))  # 1-10之间的随机整数
print(random.randrange(0, 10, 2))  # 0-10之间的随机偶数

# 生成随机浮点数
print(random.random())  # 0-1之间的随机浮点数
print(random.uniform(1, 10))  # 1-10之间的随机浮点数

# 随机选择
fruits = ["apple", "banana", "cherry"]
print(random.choice(fruits))  # 随机选择一个元素
print(random.sample(fruits, 2))  # 随机选择2个不重复的元素

# 打乱列表
random.shuffle(fruits)
print(fruits)  # 打乱后的列表

# 生成随机序列
print([random.randint(1, 10) for _ in range(5)])  # 生成5个1-10之间的随机整数

2.6.3 statistics模块

提供统计函数（Python 3.4+）：

import statistics

# 数据
numbers = [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]

# 集中趋势
print(statistics.mean(numbers))  # 5.454545454545454 平均值
print(statistics.median(numbers))  # 5 中位数
print(statistics.mode(numbers))  # 5 众数

# 离散程度
print(statistics.variance(numbers))  # 8.231884057971014 方差
print(statistics.stdev(numbers))  # 2.869125974211465 标准差
print(statistics.pvariance(numbers))  # 7.55 总体方差
print(statistics.pstdev(numbers))  # 2.747726333082368 总体标准差

2.7 日期和时间

2.7.1 datetime模块

提供日期和时间处理功能：

from datetime import datetime, date, time, timedelta

# 获取当前日期和时间
now = datetime.now()
print(now)  # 2023-05-15 14:30:45.123456

# 创建日期
d = date(2023, 5, 15)
print(d)  # 2023-05-15
print(d.year, d.month, d.day)  # 2023 5 15

# 创建时间
t = time(14, 30, 45)
print(t)  # 14:30:45
print(t.hour, t.minute, t.second)  # 14 30 45

# 创建日期时间
dt = datetime(2023, 5, 15, 14, 30, 45)
print(dt)  # 2023-05-15 14:30:45

# 日期时间格式化
print(dt.strftime("%Y-%m-%d %H:%M:%S"))  # 2023-05-15 14:30:45
print(dt.strftime("%A, %B %d, %Y"))  # Monday, May 15, 2023

# 解析日期时间字符串
parsed_dt = datetime.strptime("2023-05-15 14:30:45", "%Y-%m-%d %H:%M:%S")
print(parsed_dt)  # 2023-05-15 14:30:45

# 日期时间计算
delta = timedelta(days=1, hours=2, minutes=30)
print(dt + delta)  # 2023-05-16 17:00:45

# 日期时间差
dt1 = datetime(2023, 5, 15)
dt2 = datetime(2023, 6, 1)
diff = dt2 - dt1
print(diff.days)  # 17 相差的天数

2.7.2 calendar模块

提供日历相关功能：

import calendar

# 打印月份日历
print(calendar.month(2023, 5))  # 打印2023年5月的日历

# 打印年份日历
print(calendar.calendar(2023))  # 打印2023年的全年日历

# 检查是否为闰年
print(calendar.isleap(2023))  # False
print(calendar.isleap(2024))  # True

# 获取每月的天数
print(calendar.monthrange(2023, 5))  # (0, 31) 第一个元素是该月第一天是星期几（0=周一），第二个元素是该月的天数

# 获取月的第一天是星期几
print(calendar.weekday(2023, 5, 1))  # 0 周一

2.8 系统交互

2.8.1 sys模块

提供与Python解释器交互的功能：

import sys

# 命令行参数
print(sys.argv)  # 打印命令行参数列表

# Python版本信息
print(sys.version)  # 打印Python版本
print(sys.version_info)  # 打印Python版本信息的命名元组

# 路径信息
print(sys.path)  # 打印Python模块搜索路径

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

2.8.2 subprocess模块

提供启动和控制子进程的功能：

import subprocess

# 执行命令并获取输出
result = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(result.stdout)  # 输出命令的标准输出
print(result.stderr)  # 输出命令的标准错误
print(result.returncode)  # 输出命令的返回码

# 执行shell命令
result = subprocess.run("ls -l | grep .py", shell=True, capture_output=True, text=True)
print(result.stdout)

# 交互式执行命令
proc = subprocess.Popen(["python3"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
stdout, stderr = proc.communicate("print('Hello, World!')\nquit()")
print(stdout)  # Hello, World!

2.8.3 argparse模块

提供命令行参数解析功能：

import argparse

# 创建解析器
parser = argparse.ArgumentParser(description="A simple program to greet users")

# 添加参数
parser.add_argument("name", type=str, help="Your name")
parser.add_argument("-a", "--age", type=int, default=18, help="Your age (default: 18)")
parser.add_argument("-v", "--verbose", action="store_true", help="Increase verbosity")

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

# 使用参数
if args.verbose:
    print(f"Verbose mode enabled")
print(f"Hello, {args.name}! You are {args.age} years old.")

3. 高级功能模块

3.1 加密和安全

3.1.1 hashlib模块

提供哈希算法：

import hashlib

# MD5哈希
md5_hash = hashlib.md5()
md5_hash.update(b"Hello, World!")
print(md5_hash.hexdigest())  # 6cd3556deb0da54bca060b4c39479839

# SHA-1哈希
sha1_hash = hashlib.sha1()
sha1_hash.update(b"Hello, World!")
print(sha1_hash.hexdigest())  # 0a4d55a8d778e5022fab701977c5d840bbc486d0

# SHA-256哈希
sha256_hash = hashlib.sha256()
sha256_hash.update(b"Hello, World!")
print(sha256_hash.hexdigest())  # a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e

# 带盐的哈希
import os
password = b"mypassword"
salt = os.urandom(16)  # 生成16字节的随机盐
key = hashlib.pbkdf2_hmac("sha256", password, salt, 100000)
print(key.hex())  # 带盐的哈希值

3.1.2 secrets模块

提供安全的随机数生成（Python 3.6+）：

import secrets
import string

# 生成安全的随机字节
print(secrets.token_bytes(16))  # 生成16字节的随机数据

# 生成安全的十六进制字符串
print(secrets.token_hex(16))  # 生成32位的十六进制随机字符串

# 生成安全的URL安全字符串
print(secrets.token_urlsafe(16))  # 生成URL安全的随机字符串

# 生成强密码
alphabet = string.ascii_letters + string.digits + string.punctuation
password = ''.join(secrets.choice(alphabet) for i in range(16))
print(password)  # 生成16位的强密码

# 随机选择元素（安全的choice）
fruits = ["apple", "banana", "cherry"]
print(secrets.choice(fruits))  # 安全地随机选择一个元素

3.2 数据序列化

3.2.1 json模块

提供JSON数据处理功能：

import json

# JSON序列化（Python对象转JSON字符串）
data = {
    "name": "Zhang San",
    "age": 30,
    "is_student": False,
    "courses": ["Math", "Science", "History"]
}
json_str = json.dumps(data)
print(json_str)  # {"name": "Zhang San", "age": 30, "is_student": false, "courses": ["Math", "Science", "History"]}

# JSON反序列化（JSON字符串转Python对象）
parsed_data = json.loads(json_str)
print(parsed_data["name"])  # Zhang San

# JSON文件操作
with open("data.json", "w") as f:
    json.dump(data, f, indent=4)  # 写入JSON文件，indent=4表示格式化输出

with open("data.json", "r") as f:
    file_data = json.load(f)  # 读取JSON文件
    print(file_data)

3.2.2 pickle模块

提供Python对象的序列化和反序列化功能：

import pickle

# 定义一个类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Person(name='{self.name}', age={self.age})"

# 创建对象
p = Person("Zhang San", 30)

# 序列化（对象转字节）
pickled = pickle.dumps(p)
print(pickled)  # b'\x80\x04\x95\x1f\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x06Person\x94\x93\x94)\x81\x94}\x94(\x8c\x04name\x94\x8c\x08Zhang San\x94\x8c\x03age\x94K\x1eub.'

# 反序列化（字节转对象）
unpickled = pickle.loads(pickled)
print(unpickled)  # Person(name='Zhang San', age=30)

# 文件操作
with open("person.pkl", "wb") as f:
    pickle.dump(p, f)  # 写入pickle文件

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

3.3 调试和测试

3.3.1 logging模块

提供日志记录功能：

import logging

# 配置日志
logging.basicConfig(
    level=logging.DEBUG,  # 日志级别
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",  # 日志格式
    handlers=[
        logging.FileHandler("app.log"),  # 输出到文件
        logging.StreamHandler()  # 输出到控制台
    ]
)

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

# 记录日志
logger.debug("This is a debug message")
logger.info("This is an info message")
logger.warning("This is a warning message")
logger.error("This is an error message")
logger.critical("This is a critical message")

3.3.2 unittest模块

提供单元测试框架：

import unittest

# 定义要测试的函数
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# 测试类
class TestMathFunctions(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)  # 断言add(2, 3)等于5
        self.assertEqual(add(-1, 1), 0)  # 断言add(-1, 1)等于0
        self.assertEqual(add(0, 0), 0)  # 断言add(0, 0)等于0
    
    def test_subtract(self):
        self.assertEqual(subtract(5, 3), 2)  # 断言subtract(5, 3)等于2
        self.assertEqual(subtract(3, 5), -2)  # 断言subtract(3, 5)等于-2

# 运行测试
if __name__ == "__main__":
    unittest.main()

4. 工具和辅助模块

4.1 itertools模块

提供用于创建高效迭代器的工具：

import itertools

# 无限迭代器
count = itertools.count(1, 2)  # 从1开始，步长为2的无限迭代器
print(next(count))  # 1
print(next(count))  # 3
print(next(count))  # 5

cycle = itertools.cycle(["A", "B", "C"])  # 无限循环迭代器
print(next(cycle))  # A
print(next(cycle))  # B
print(next(cycle))  # C
print(next(cycle))  # A

repeat = itertools.repeat("Hello", 3)  # 重复3次的迭代器
print(list(repeat))  # ['Hello', 'Hello', 'Hello']

# 有限迭代器
data = [1, 2, 3]

# 累积
print(list(itertools.accumulate(data)))  # [1, 3, 6] 累积和
print(list(itertools.accumulate(data, lambda x, y: x * y)))  # [1, 2, 6] 累积乘积

# 链
print(list(itertools.chain([1, 2, 3], [4, 5, 6])))  # [1, 2, 3, 4, 5, 6]

# 压缩
print(list(itertools.compress(["A", "B", "C", "D"], [1, 0, 1, 0])))  # ['A', 'C']

# 过滤
print(list(itertools.filterfalse(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])))  # [1, 3, 5]

# 分组
for key, group in itertools.groupby("AAABBBCCAAA"):
    print(key, list(group))  # A ['A', 'A', 'A']
                            # B ['B', 'B', 'B']
                            # C ['C', 'C']
                            # A ['A', 'A', 'A']

# 排列组合
print(list(itertools.permutations([1, 2, 3], 2)))  # [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
print(list(itertools.combinations([1, 2, 3], 2)))  # [(1, 2), (1, 3), (2, 3)]

4.2 functools模块

提供高阶函数工具：

import functools

# 部分应用函数
add5 = functools.partial(lambda x, y: x + y, y=5)
print(add5(10))  # 15

# 缓存装饰器
@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55
print(fibonacci.cache_info())  # CacheInfo(hits=8, misses=11, maxsize=128, currsize=11)

# 单例装饰器
def singleton(cls):
    @functools.wraps(cls)
    def wrapper(*args, **kwargs):
        if not wrapper.instance:
            wrapper.instance = cls(*args, **kwargs)
        return wrapper.instance
    wrapper.instance = None
    return wrapper

@singleton
class MySingleton:
    def __init__(self):
        self.value = 0

# 使用单例
s1 = MySingleton()
s1.value = 5
s2 = MySingleton()
print(s1.value)  # 5
print(s2.value)  # 5
s2.value = 10
print(s1.value)  # 10

4.3 contextlib模块

提供上下文管理器工具：

import contextlib
import os

# 自定义上下文管理器
@contextlib.contextmanager
def temporary_file(filename, mode="w"):
    try:
        f = open(filename, mode)
        yield f
    finally:
        f.close()
        os.remove(filename)

# 使用自定义上下文管理器
with temporary_file("temp.txt") as f:
    f.write("Hello, World!")
    
# 文件已被删除
print(os.path.exists("temp.txt"))  # False

# 关闭多个资源
with contextlib.ExitStack() as stack:
    f1 = stack.enter_context(open("file1.txt", "w"))
    f2 = stack.enter_context(open("file2.txt", "w"))
    f1.write("Hello")
    f2.write("World")
# 两个文件都已关闭

5. 标准库使用技巧和最佳实践

5.1 优先使用标准库

• 标准库经过严格测试，质量可靠
• 标准库与Python解释器紧密集成，性能优化
• 标准库无需额外安装，提高代码的可移植性

5.2 了解模块的最佳实践

• 阅读模块的文档字符串
• 了解模块的常见用例
• 遵循模块的API设计

5.3 避免重新实现标准库功能

• 标准库提供了丰富的功能，避免重复造轮子
• 例如：使用collections.Counter而不是自己实现计数功能

5.4 注意性能问题

• 某些标准库模块的性能可能不是最优的
• 例如：对于大规模数据处理，pandas可能比标准库的csv模块更高效

5.5 保持代码的兼容性

• 注意不同Python版本之间的API变化
• 使用__future__模块启用新特性
• 例如：from __future__ import print_function

6. 总结

Python标准库是Python语言的核心优势之一，它提供了丰富的功能模块，涵盖了从基本操作到高级应用的各个方面。熟练掌握标准库的使用，可以大大提高开发效率，编写更高效、更可靠的代码。

本文介绍了Python标准库的主要模块，包括：

• 文本处理
• 文件和目录操作
• 数据结构
• 网络编程
• 并发编程
• 数学计算
• 日期和时间
• 系统交互
• 调试和测试
• 加密和安全
• 数据序列化
• 工具和辅助模块

通过学习和使用这些模块，可以更好地发挥Python的强大功能，解决实际开发中的各种问题。

发布网站：荣殿教程（zhangrongdian.com） 作者：张荣殿 发布日期：2026-01-19