备案号:蜀ICP备2026035467号-3|网站:www.xservx.com

python标准库参考手册

Python标准库是Python语言发行版中自带的一整套模块与包集合,覆盖了从基础数据结构到高级网络编程的广泛功能。作为Python语言强大生产力的重要支撑,标准库遵循“电池齐全”(batteries included)的设计哲学,为开发者提供了即开即用的高质量工具链。本手册系统梳理了Python标准库的核心模块体系,结合实际应用场景提供详实示例与深度解析,帮助开发者快速掌握标准库的关键特性与最佳实践。

Python标准库具有以下显著优势:

  • 跨平台兼容性:所有模块均经过Windows、macOS、Linux等主流操作系统的严格测试,确保一致的行为表现;
  • 模块化设计:每个模块职责单一、接口清晰,便于组合使用与独立替换;
  • 文档完善:官方文档详尽权威,配合大量示例代码与使用技巧;
  • 长期维护:核心模块受Python社区持续维护,遵循严格的向后兼容性策略;
  • 零额外依赖:无需安装第三方包即可直接使用,降低部署复杂度。

标准库按功能划分为多个模块家族,包括:内置类型与异常、数值与数学模块、数据结构与算法、文件与目录处理、日期与时间、文本处理、二进制数据处理、并发与并行、网络与互联网、脚本与交互、开发工具、系统交互等。每个模块均经过精心设计,在性能、可读性与可维护性之间取得良好平衡。

值得注意的是,Python标准库的演进严格遵循PEP(Python Enhancement Proposals)流程。任何新模块的加入或现有模块的修改,都需经过社区讨论、设计评审、实现测试、文档完善等多个阶段。这一机制确保了标准库的长期稳定性与技术先进性。例如,asyncio模块的诞生源于PEP 3156,其引入协程原语彻底改变了Python的异步编程范式;pathlib模块则通过PEP 428提供了面向对象的文件系统路径操作接口,极大提升了代码可读性。

本手册不仅涵盖标准库的核心模块,还特别关注开发者在实际项目中常遇到的典型场景与挑战。我们深入探讨了模块间的协同使用策略、性能优化技巧、常见陷阱规避方法,以及与第三方生态的集成要点。通过大量真实案例与对比分析,帮助读者建立系统化的知识结构,实现从“能用”到“善用”的跨越。

核心基础模块详解

Python标准库中的核心模块构成了整个语言功能体系的基石。它们提供了最基础的数据类型、运算符重载、异常处理机制以及运行时环境控制能力。深入理解这些模块的工作原理,是编写高效、健壮Python代码的前提。

内置类型与数据结构

Python的内置类型系统是其强大表达能力的核心。标准库中的builtins模块定义了如int、float、str、list、dict、tuple、set、frozenset等基础类型,这些类型均支持丰富的内置方法与操作符重载。

特别值得注意的是collections模块提供的高级容器类型:

  • namedtuple:创建具名元组,提升代码可读性。例如:
    from collections import namedtuple
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(3, 4)
    print(p.x, p.y) # 输出:3 4
  • deque:双端队列,支持O(1)时间复杂度的首尾添加/删除操作,适用于队列与栈场景。
  • Counter:计数器,高效统计可哈希对象的出现频率:
    from collections import Counter
    text = "hello world"
    freq = Counter(text)
    print(freq.most_common(2)) # [('l', 3), ('o', 2)]
  • defaultdict:带默认值的字典,避免键不存在时的KeyError异常。
  • OrderedDict:保持插入顺序的字典(Python 3.7+中dict已具备此特性)。

此外,array模块提供高效存储同类型数值的数组,heapq模块实现堆队列算法(优先队列),bisect模块支持二分查找与有序插入操作,这些在算法竞赛与性能敏感场景中尤为关键。

运算符与表达式机制

Python的运算符重载机制允许自定义类实现特定运算行为。标准库通过operator模块提供了大量函数式接口,对应内置运算符:

  • 算术运算:add、sub、mul、truediv、floordiv、mod、pow等
  • 比较运算:lt、le、eq、ne、ge、gt
  • 逻辑运算:and_、or_、not_、xor
  • 位运算:and_、or_、xor、invert、lshift、rshift
  • 序列操作:getitem、setitem、delitem、contains
  • 属性访问:attrgetter、itemgetter、methodcaller

示例:使用itemgetter进行多键排序

from operator import itemgetter
data = [{'name':'Alice','age':30},{'name':'Bob','age':25},{'name':'Charlie','age':35}]
sorted_data = sorted(data, key=itemgetter('age','name'))
print(sorted_data)
# [{'name':'Bob','age':25},{'name':'Alice','age':30},{'name':'Charlie','age':35}]

functools模块提供了高级函数操作工具:

  • partial:偏函数应用,固定部分参数生成新函数
  • reduce:将二元函数累积应用于序列(Python 3中移至functools)
  • lru_cache:最近最少使用缓存装饰器,显著提升递归与重复计算性能
  • total_ordering:根据部分比较方法自动生成其余比较方法
  • wraps:装饰器工厂,保留被装饰函数的元数据(__name__、__doc__等)
异常处理体系

Python的异常继承体系以BaseException为根节点,主要分支包括:

  • Exception:所有非系统退出异常的基类
  • ArithmeticError:算术运算异常基类(ZeroDivisionError、OverflowError等)
  • LookupError:索引/键查找异常基类(IndexError、KeyError)
  • ValueError:值类型正确但值无效
  • TypeError:操作或函数应用于不适当类型的对象
  • IOError:输入/输出操作失败(Python 3.3+与OSError合并)

自定义异常的最佳实践:

class DataValidationError(Exception):
    """数据验证失败异常"""
    def __init__(self, field, message, details=None):
        self.field = field
        self.message = message
        self.details = details or {}
        super().__init__(f"{field}: {message}")
# 使用示例
def validate_email(email):
    if '@' not in email:
        raise DataValidationError('email', '无效邮箱格式', {'received': email})
    return email

标准库还提供了contextlib模块用于异常处理的上下文管理:

  • suppress:临时忽略指定异常类型
  • redirect_stdout:重定向标准输出流
  • ExitStack:动态管理多个上下文管理器

数据处理与算法模块

Python标准库在数据处理领域提供了强大支持,从基础数值计算到复杂算法实现均有覆盖。这些模块经过高度优化,在保证易用性的同时兼顾性能表现。

数值计算与数学工具

math模块提供数学函数(三角函数、对数、幂运算等),cmath模块处理复数数学运算。两者均针对不同数值类型进行了特殊优化。

decimal模块实现高精度十进制浮点数运算:

from decimal import Decimal, getcontext
getcontext().prec = 50  # 设置精度为50位
a = Decimal('0.1')
b = Decimal('0.2')
print(a + b)  # 精确输出0.3,而非浮点数的0.30000000000000004

fractions模块支持有理数运算:

from fractions import Fraction
f1 = Fraction(1, 3)
f2 = Fraction(2, 5)
print(f1 + f2)  # Fraction(11, 15)

statistics模块提供描述性统计函数:

  • mean()、median()、mode():平均值、中位数、众数
  • stdev()、variance():标准差、方差
  • harmonic_mean():调和平均数

random模块实现伪随机数生成:

  • random():[0,1)区间均匀分布
  • randint(a,b):[a,b]区间整数
  • choice(seq):从序列中随机选择元素
  • shuffle(x):原地打乱序列
  • sample(population,k):无放回抽样

注意:random模块适用于模拟与游戏,不适用于加密场景。

日期与时间处理

datetime模块提供日期时间处理的核心类:

  • date:日期对象(年、月、日)
  • time:时间对象(时、分、秒、微秒)
  • datetime:日期时间组合
  • timedelta:时间间隔
  • tzinfo:时区信息基类

时区处理示例:

from datetime import datetime, timezone, timedelta
# 创建UTC时间
utc_dt = datetime.now(timezone.utc)
# 转换为东八区
beijing_tz = timezone(timedelta(hours=8))
bj_dt = utc_dt.astimezone(beijing_tz)
print(bj_dt.strftime("%Y-%m-%d %H:%M:%S %Z"))

calendar模块提供日历相关功能:

  • monthcalendar(year, month):返回月日历矩阵
  • yeardays2calendar(year, width=3):返回年日历数据
  • isleap(year):判断闰年
  • leapdays(y1, y2):计算年份区间内的闰年数

time模块提供时间相关函数:

  • time():时间戳(Unix epoch)
  • sleep(secs):休眠指定秒数
  • strftime(format, tuple):格式化时间
  • strptime(string, format):解析时间字符串
数据序列化与传输

json模块实现JSON数据的编码与解码:

import json
data = {"name": "Alice", "scores": [95, 88, 92]}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)
# {
#   "name": "Alice",
#   "scores": [95, 88, 92]
# }
parsed = json.loads(json_str)

pickle模块实现Python对象序列化:

  • 适用于复杂对象(如自定义类实例)
  • 注意:不应用于处理不可信数据(存在安全风险)

struct模块处理C语言风格的二进制数据打包与解包:

import struct
# 打包为小端字节序的32位有符号整数
packed = struct.pack('
文本处理与编码

string模块提供常量与实用函数:

  • ascii_letters:所有ASCII字母
  • digits:'0123456789'
  • punctuation:所有标点符号
  • Template:字符串模板类

textwrap模块处理文本格式化:

  • wrap():将文本分割为行列表
  • fill():将文本填充为段落
  • dedent():去除缩进

re模块提供正则表达式支持:

  • re.search(pattern, string):搜索匹配
  • re.match(pattern, string):从开头匹配
  • re.findall(pattern, string):返回所有匹配项列表
  • re.sub(pattern, repl, string):替换匹配项
  • re.split(pattern, string):按模式分割

命名捕获组示例:

import re
pattern = r'(?P\d{4})-(?P\d{2})-(?P\d{2})'
match = re.search(pattern, 'Today is 2023-12-25')
if match:
    print(match.groupdict())
    # {'year': '2023', 'month': '12', 'day': '25'}

文件系统与输入输出模块

Python标准库提供了全面的文件与目录操作接口,支持跨平台路径处理、文件I/O、临时文件管理等功能。这些模块经过高度抽象,确保代码的可移植性与健壮性。

路径操作与文件系统

os.path模块提供路径操作函数:

  • join(path, *paths):智能拼接路径
  • abspath(path):获取绝对路径
  • relpath(path, start='.'):计算相对路径
  • split(path):分割为目录与文件名
  • splitext(path):分割文件名与扩展名
  • exists(path):检查路径是否存在
  • isfile/isdir(path):判断文件/目录
  • getsize(path):获取文件大小
  • getmtime(path):获取修改时间

pathlib模块(PEP 428)提供面向对象的路径操作:

from pathlib import Path
# 创建路径对象
p = Path('/home/user/docs/file.txt')
# 属性访问
print(p.parent)      # /home/user/docs
print(p.name)        # file.txt
print(p.suffix)      # .txt
print(p.stem)        # file
# 路径操作
p2 = p.with_name('new.txt')  # /home/user/docs/new.txt
p3 = p.parent / 'new.txt'    # 同上
# 文件操作
if p.exists():
    content = p.read_text(encoding='utf-8')
    p.write_text('Hello\nWorld', encoding='utf-8')

优势:链式调用、自动处理平台差异、类型安全。

文件I/O操作

标准文件对象方法:

  • read(size=-1):读取指定字节数
  • readline(size=-1):读取一行
  • readlines(hint=-1):读取多行
  • write(string):写入字符串
  • writelines(lines):写入多行
  • seek(offset, whence=0):移动文件指针
  • tell():获取当前指针位置
  • flush():刷新缓冲区
  • close():关闭文件

上下文管理器确保文件正确关闭:

with open('data.txt', 'r', encoding='utf-8') as f:
    for line in f:
        process(line)

io模块提供内存中的I/O操作:

  • StringIO:文本缓冲区
  • BytesIO:二进制缓冲区
  • TextIOWrapper:文本I/O包装器
临时文件与目录

tempfile模块安全创建临时文件与目录:

  • tempfile():创建临时文件
  • NamedTemporaryFile():创建带名称的临时文件
  • TemporaryDirectory():创建临时目录
  • mkstemp():创建临时文件(返回文件描述符)
  • mkdtemp():创建临时目录

使用示例:

import tempfile
with tempfile.NamedTemporaryFile(mode='w+', delete=False) as tmp:
    tmp.write('Temporary data')
    path = tmp.name
print(f"临时文件路径:{path}")
# 手动删除(delete=False时)
import os
os.unlink(path)
文件监控与变化检测

watchdog虽为第三方库,但标准库提供了基础监控能力:

  • os.scandir():高效目录遍历(Python 3.5+)
  • os.stat():获取文件状态
  • os.path.getmtime():获取修改时间

简单监控实现:

import os
import time
def monitor_directory(path, interval=1):
    last_mtime = {f: os.path.getmtime(os.path.join(path, f))
                  for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))}
    while True:
        time.sleep(interval)
        current_mtime = {f: os.path.getmtime(os.path.join(path, f))
                        for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))}
        for f in set(last_mtime.keys()) | set(current_mtime.keys()):
            if f not in last_mtime:
                print(f"新增文件:{f}")
            elif f not in current_mtime:
                print(f"删除文件:{f}")
            elif last_mtime[f] != current_mtime[f]:
                print(f"修改文件:{f}")
        last_mtime = current_mtime

网络开发与通信模块

Python标准库提供了从底层套接字到高层协议的完整网络编程支持,涵盖HTTP、FTP、SMTP等常见协议的客户端与服务端实现。这些模块经过高度封装,使开发者能够快速构建网络应用。

底层网络接口

socket模块提供BSD套接字接口:

import socket
# TCP服务端
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)
conn, addr = server.accept()
data = conn.recv(1024)
conn.send(b'Hello Client')
conn.close()
server.close()
# TCP客户端
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8080))
client.send(b'Hello Server')
response = client.recv(1024)
client.close()

select模块实现I/O多路复用:

  • select(rlist, wlist, xlist, timeout):监控文件描述符
  • poll():更高效的轮询接口
  • epoll(Linux):事件驱动的I/O多路复用

多客户端服务器示例:

import socket, select
serversock = socket.socket()
serversock.bind(('127.0.0.1', 8080))
serversock.listen(5)
inputs = [serversock]
while True:
    readable, _, _ = select.select(inputs, [], [])
    for s in readable:
        if s is serversock:
            conn, addr = serversock.accept()
            inputs.append(conn)
        else:
            data = s.recv(1024)
            if data:
                s.send(data)
            else:
                inputs.remove(s)
                s.close()
HTTP协议实现

http.server模块提供简单HTTP服务器:

from http.server import HTTPServer, BaseHTTPRequestHandler
class SimpleHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'Hello, HTTP!')
server = HTTPServer(('127.0.0.1', 8000), SimpleHandler)
server.serve_forever()

urllib模块提供URL处理与HTTP客户端:

  • urlopen():打开URL
  • Request():构造HTTP请求
  • parse_qs():解析查询字符串
  • urlencode():编码查询字符串

POST请求示例:

import urllib.request, urllib.parse
data = urllib.parse.urlencode({'name': 'Alice', 'age': 30}).encode()
req = urllib.request.Request('http://example.com/api', data=data, method='POST')
with urllib.request.urlopen(req) as response:
    result = response.read().decode()

http.client模块提供底层HTTP客户端:

import http.client
conn = http.client.HTTPConnection("example.com")
conn.request("GET", "/")
response = conn.getresponse()
print(response.status, response.reason)
data = response.read()
conn.close()
邮件协议支持

smtplib模块实现SMTP客户端:

import smtplib
from email.mime.text import MIMEText
from email.header import Header
msg = MIMEText('Hello, this is a test email.', 'plain', 'utf-8')
msg['From'] = Header('Sender', 'utf-8')
msg['To'] = Header('Recipient', 'utf-8')
msg['Subject'] = Header('Test Email', 'utf-8')
server = smtplib.SMTP('smtp.example.com', 587)
server.starttls()
server.login('user@example.com', 'password')
server.sendmail('user@example.com', ['recipient@example.com'], msg.as_string())
server.quit()

imaplib模块实现IMAP客户端:

import imaplib, email
mail = imaplib.IMAP4_SSL('imap.example.com')
mail.login('user@example.com', 'password')
mail.select('INBOX')
status, data = mail.search(None, 'ALL')
for num in data[0].split():
    status, msg_data = mail.fetch(num, '(RFC822)')
    msg = email.message_from_bytes(msg_data[0][1])
    print(f"Subject: {msg['Subject']}")
FTP与Telnet客户端

ftplib模块实现FTP客户端:

from ftplib import FTP
ftp = FTP('ftp.example.com')
ftp.login('user', 'password')
ftp.cwd('/public')
with open('file.txt', 'wb') as f:
    ftp.retrbinary('RETR file.txt', f.write)
ftp.quit()

telnetlib模块实现Telnet客户端:

import telnetlib
tn = telnetlib.Telnet('localhost', 23)
tn.read_until(b"login: ")
tn.write(b"user\n")
tn.read_until(b"Password: ")
tn.write(b"password\n")
tn.write(b"ls\n")
print(tn.read_all().decode('ascii'))
tn.close()

安全与加密模块

Python标准库提供了基础的安全与加密功能,涵盖哈希计算、随机数生成、数字签名、SSL/TLS支持等。开发者需注意:标准库提供的是基础工具,复杂安全需求建议结合专业安全库使用。

哈希与消息摘要

hashlib模块提供安全哈希算法:

  • md5():MD5哈希(不推荐用于安全场景)
  • sha1():SHA-1哈希(已不推荐)
  • sha256()、sha512():SHA-2系列
  • blake2b()、blake2s():BLAKE2哈希(Python 3.6+)

使用示例:

import hashlib
# 计算文件SHA-256
def file_sha256(filepath):
    h = hashlib.sha256()
    with open(filepath, 'rb') as f:
        for chunk in iter(lambda: f.read(8192), b''):
            h.update(chunk)
    return h.hexdigest()
# 验证密码
password = "my_password"
salt = hashlib.sha256(os.urandom(64)).hexdigest()
hashed = hashlib.sha256((salt + password).encode()).hexdigest()

hmac模块实现基于哈希的消息认证码:

import hmac, hashlib
message = b"Important message"
key = b"secret_key"
digest = hmac.new(key, message, hashlib.sha256).hexdigest()
随机数与密码学安全

secrets模块提供密码学安全的随机数生成:

  • token_bytes(nbytes):生成随机字节
  • token_hex(nbytes):生成十六进制字符串
  • token_urlsafe(nbytes):生成URL安全的令牌

密码重置令牌示例:

import secrets
def generate_reset_token():
    return secrets.token_urlsafe(32)
token = generate_reset_token()
print(f"重置链接:https://example.com/reset?token={token}")

注意:random模块不适用于安全场景,因其生成的随机数可预测。

SSL/TLS支持

ssl模块提供SSL/TLS加密通信:

import ssl, socket
context = ssl.create_default_context()
with socket.create_connection(('www.example.com', 443)) as sock:
    with context.wrap_socket(sock, server_hostname='www.example.com') as ssock:
        print(ssock.version())
        ssock.sendall(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")
        print(ssock.recv(4096).decode())

http.client与urllib.request自动使用SSL上下文处理HTTPS连接。

数字签名与加密

标准库不提供完整的公钥加密实现,但可通过cryptography第三方库扩展。基础加密支持包括:

  • os.urandom():生成加密级随机数
  • hashlib.pbkdf2_hmac():密码学密钥派生

密钥派生示例:

import hashlib, os
password = b"my_password"
salt = os.urandom(16)
key = hashlib.pbkdf2_hmac('sha256', password, salt, 100000)

实用开发工具模块

Python标准库提供了丰富的开发工具,涵盖调试、测试、性能分析、代码检查等方面。这些工具帮助开发者提高代码质量与开发效率。

调试与日志

logging模块提供灵活的日志系统:

import logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('app.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)
logger.info("Application started")
logger.error("Error occurred", exc_info=True)

pdb模块提供交互式调试器:

  • break(file, line):设置断点
  • continue():继续执行
  • step():单步执行
  • next():单步跳过
  • print(expr):打印表达式
  • quit():退出调试

使用方式:

import pdb
def complex_calculation(data):
    result = 0
    for item in data:
        result += item * 2
        pdb.set_trace()  # 设置断点
    return result
性能分析与优化

timeit模块测量代码执行时间:

import timeit
code = """
result = []
for i in range(1000):
    result.append(i * 2)
"""
print(timeit.timeit(code, number=10000))

cProfile模块提供性能分析:

import cProfile, pstats
def main():
    # 复杂计算
    pass
profiler = cProfile.Profile()
profiler.enable()
main()
profiler.disable()
stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(20)

trace模块跟踪代码执行:

  • 跟踪函数调用
  • 生成覆盖率报告
  • 分析执行路径
单元测试框架

unittest模块提供完整的测试框架:

import unittest
class TestMathOperations(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(1 + 1, 2)
    def test_division_by_zero(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0
if __name__ == '__main__':
    unittest.main()

支持特性:

  • 测试用例(TestCase)
  • 测试套件(TestSuite)
  • 测试夹具(setUp/tearDown)
  • 跳过测试(@unittest.skip)
  • 参数化测试(subTest)

doctest模块通过文档字符串测试:

def square(x):
    """计算平方
    >>> square(2)
    4
    >>> square(-3)
    9
    """
    return x * x
代码检查与格式化

pyclbr模块解析Python代码结构:

import pyclbr
modules = pyclbr.readmodule(['my_module'])
for name, obj in modules.items():
    print(f"类: {name}")
    print(f"  方法: {[m.name for m in obj.methods.values()]}")

ast模块解析抽象语法树:

import ast
code = "x = 1 + 2 * 3"
tree = ast.parse(code)
print(ast.dump(tree, indent=2))

开发者常见问题解答

模块导入机制
性能优化技巧
并发编程模型
跨平台兼容性

模块导入机制详解

Python的模块导入系统是其强大动态特性的核心体现。理解导入机制有助于解决常见的导入错误与性能问题。

导入流程:

  1. 检查sys.modules缓存(避免重复导入)
  2. 搜索sys.path中的路径
  3. 加载模块(执行模块代码)
  4. 在命名空间中注册模块

导入方式对比:

  • import module:导入整个模块,使用时需加前缀
  • from module import name:导入特定名称,直接使用
  • import module as alias:使用别名
  • from module import *:导入所有公共名称(不推荐)

相对导入:

  • .module:同级模块
  • ..module:上级模块
  • ...module:上上级模块

导入陷阱:

  • 循环导入:模块A导入B,B又导入A
  • 命名冲突:多个模块含同名函数
  • 延迟导入:在函数内导入避免启动延迟

最佳实践:

  • 使用绝对导入而非相对导入
  • 避免在模块顶层执行耗时操作
  • 使用lazy imports处理可选依赖
  • 在__init__.py中明确声明__all__

性能优化关键技巧

Python代码的性能优化需在可读性与执行效率间取得平衡。标准库提供了多种性能优化工具与策略。

字符串拼接优化:

items = ['Hello', 'World', 'Python']
# 低效:使用+号
s = ""
for item in items:
    s += item + " "
# 高效:使用join
s = " ".join(items)

列表推导式 vs 循环:

# 创建平方数列表
squares = [i * i for i in range(1000)]  # 推荐
# vs
squares = []
for i in range(1000):
    squares.append(i * i)

生成器表达式:

# 内存友好:不一次性生成所有元素
total = sum(i * i for i in range(1000000))

使用内置函数:

  • max/min:比手动循环快
  • sorted:Timsort算法,稳定高效
  • any/all:短路求值
  • enumerate:避免手动计数

缓存策略:

from functools import lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

避免全局变量:局部变量访问更快

使用C扩展模块:如numpy、pandas处理数值计算

并发编程模型比较

Python提供多种并发编程模型,适用于不同场景需求。

多线程(threading):

  • 适用于I/O密集型任务(网络请求、文件操作)
  • 受GIL限制,CPU密集型任务效果有限
  • 线程间共享内存,需注意同步问题
import threading, time
def worker(name, delay):
    print(f"Thread {name} starting")
    time.sleep(delay)
    print(f"Thread {name} finished")
threads = []
for i in range(3):
    t = threading.Thread(target=worker, args=(i, 1))
    threads.append(t)
    t.start()
for t in threads:
    t.join()

多进程(multiprocessing):

  • 适用于CPU密集型任务
  • 每个进程有独立GIL,可真正并行
  • 进程间通信需使用Queue/Pipe
from multiprocessing import Pool
def square(x):
    return x * x
with Pool(4) as p:
    results = p.map(square, [1, 2, 3, 4, 5])

异步编程(asyncio):

  • 适用于高并发I/O操作
  • 单线程实现并发,避免线程开销
  • 使用协程(coroutine)而非线程
import asyncio
async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1)  # 模拟网络请求
    return f"Data from {url}"
async def main():
    urls = ['http://a.com', 'http://b.com', 'http://c.com']
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)
asyncio.run(main())

选择建议:

  • I/O密集型:asyncio > 多线程
  • CPU密集型:多进程 > 多线程
  • 混合场景:组合使用多种模型

跨平台兼容性策略

Python标准库设计时充分考虑了跨平台需求,但某些平台特定功能仍需特殊处理。

路径分隔符:

  • 使用os.path.join()而非硬编码
  • 使用pathlib.Path自动处理差异

换行符:

  • Windows:\r\n
  • Unix/Linux:\n
  • Mac(旧版):\r
  • 使用newline=None自动处理

文件系统:

  • 大小写敏感性(Linux大小写敏感,Windows不敏感)
  • 文件名长度限制
  • 特殊字符限制(如Windows禁止<>:"|?*)

环境变量:

import os
# 获取环境变量
home_dir = os.environ.get('HOME') or os.environ.get('USERPROFILE')

进程管理:

  • os.fork()仅限Unix
  • subprocess模块跨平台

系统调用:

  • 使用platform模块检测系统类型
  • 提供平台特定的实现分支
import platform
if platform.system() == 'Windows':
    # Windows特定代码
    pass
elif platform.system() == 'Darwin':
    # macOS特定代码
    pass
else:
    # Unix/Linux代码
    pass
网友们都还关心