Python 标准库完全指南

本文档面向零基础新手，目标是让你掌握 Python 最常用的内置模块，做到：

知道标准库是什么，怎么用
熟练使用 random、datetime、os、math、json 等高频模块
了解 collections、pathlib、re、itertools 等进阶模块
遇到问题时知道去哪找答案

所有示例均可直接运行。

第一部分：什么是标准库？

1.1 标准库的定义

Python 安装完成后，自带了大量可以直接使用的模块，这些模块的集合称为 标准库（Standard Library）。

你不需要安装任何第三方包，只需要 import 模块名 就能使用。

import math          # 数学
import random        # 随机数
import datetime      # 日期时间
import os            # 操作系统接口
import json          # JSON 格式处理
import re            # 正则表达式
# ... 还有数百个模块

1.2 标准库 vs 第三方库

类型	举例	使用方法
标准库	`math`、`random`、`os`	直接 `import`，无需安装
第三方库	`numpy`、`pandas`、`requests`	先用 `pip install` 安装，再 `import`

1.3 查看标准库文档

官方文档（中文版）：https://docs.python.org/zh-cn/3/library/

第二部分：random——随机数

2.1 基础用法

import random

# 生成 [0.0, 1.0) 之间的随机浮点数
print(random.random())          # 如：0.37444887175646646

# 生成指定范围内的随机整数（包含两端）
print(random.randint(1, 10))    # 如：7

# 生成 [a, b) 之间的随机浮点数
print(random.uniform(1.5, 5.5)) # 如：3.2847

# 生成 [start, stop) 步长为 step 的随机整数（同 range）
print(random.randrange(0, 100, 5))  # 0, 5, 10, ..., 95 中随机一个

2.2 从序列中随机选取

import random

fruits = ["苹果", "香蕉", "草莓", "葡萄", "芒果"]

# 随机选 1 个
print(random.choice(fruits))          # 如：草莓

# 随机选 k 个（有放回，可重复）
print(random.choices(fruits, k=3))    # 如：['香蕉', '苹果', '香蕉']

# 随机选 k 个（无放回，不重复）
print(random.sample(fruits, k=3))     # 如：['芒果', '苹果', '草莓']

2.3 打乱顺序

import random

cards = list(range(1, 11))   # [1, 2, 3, ..., 10]
print("打乱前：", cards)

random.shuffle(cards)         # 原地打乱，无返回值
print("打乱后：", cards)      # 如：[7, 3, 9, 1, 5, 2, 8, 6, 4, 10]

2.4 设置随机种子（让结果可重现）

import random

random.seed(42)    # 设置种子后，每次运行结果相同
print(random.randint(1, 100))   # 永远是 82（种子固定，结果固定）
print(random.randint(1, 100))   # 永远是 15

2.5 实战：模拟摇骰子

import random

def roll_dice(sides=6, count=2):
    """模拟摇骰子"""
    results = [random.randint(1, sides) for _ in range(count)]
    total   = sum(results)
    print(f"摇了 {count} 个 {sides} 面骰子：{results}，总点数：{total}")
    return total

roll_dice()           # 2 个 6 面骰子
roll_dice(20, 1)      # 1 个 20 面骰子

第三部分：datetime——日期和时间

3.1 获取当前日期和时间

from datetime import datetime, date, time, timedelta

# 当前日期时间
now = datetime.now()
print(now)                   # 2024-03-11 14:30:25.123456
print(type(now))             # <class 'datetime.datetime'>

# 只要日期
today = date.today()
print(today)                 # 2024-03-11
print(today.year)            # 2024
print(today.month)           # 3
print(today.day)             # 11

3.2 创建指定日期时间

from datetime import datetime, date

# 创建指定日期
birthday = date(1990, 5, 20)
print(birthday)   # 1990-05-20

# 创建指定日期时间
meeting = datetime(2024, 6, 1, 9, 30, 0)
print(meeting)    # 2024-06-01 09:30:00

3.3 格式化显示（strftime）

strftime = string format time，把日期时间对象转成你想要的字符串格式。

from datetime import datetime

now = datetime.now()

# 常用格式代码
print(now.strftime("%Y-%m-%d"))            # 2024-03-11（年-月-日）
print(now.strftime("%Y年%m月%d日"))        # 2024年03月11日
print(now.strftime("%H:%M:%S"))            # 14:30:25（时:分:秒）
print(now.strftime("%Y-%m-%d %H:%M:%S"))   # 2024-03-11 14:30:25
print(now.strftime("%A"))                   # Monday（星期几，英文）
print(now.strftime("%p %I:%M"))            # PM 02:30（12小时制）

常用格式代码速查：

代码	含义	示例
`%Y`	四位年份	2024
`%m`	两位月份（01-12）	03
`%d`	两位日期（01-31）	11
`%H`	24小时制小时（00-23）	14
`%M`	分钟（00-59）	30
`%S`	秒（00-59）	25
`%A`	星期（英文全称）	Monday
`%p`	AM 或 PM	PM

3.4 解析字符串为日期时间（strptime）

strptime = string parse time，把字符串解析成日期时间对象。

from datetime import datetime

# 字符串 → datetime 对象
date_str = "2024-06-15 10:30:00"
dt = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(dt)           # 2024-06-15 10:30:00
print(dt.year)      # 2024
print(dt.month)     # 6

# 中文格式
date_str2 = "2024年03月11日"
dt2 = datetime.strptime(date_str2, "%Y年%m月%d日")
print(dt2)          # 2024-03-11 00:00:00

3.5 日期时间计算（timedelta）

timedelta 表示一段时间间隔，可以和 date/datetime 做加减运算。

from datetime import datetime, timedelta

now = datetime.now()

# 加减天数
tomorrow       = now + timedelta(days=1)
three_days_ago = now - timedelta(days=3)
next_week      = now + timedelta(weeks=1)

print(tomorrow.strftime("%Y-%m-%d"))        # 明天
print(three_days_ago.strftime("%Y-%m-%d"))  # 三天前

# 加减小时、分钟、秒
two_hours_later = now + timedelta(hours=2, minutes=30)
print(two_hours_later.strftime("%H:%M"))

# 计算两个日期之间的差
start = datetime(2024, 1, 1)
end   = datetime(2024, 12, 31)
diff  = end - start
print(f"2024年共 {diff.days} 天")   # 2024年共 365 天

3.6 实战：计算年龄

from datetime import date

def calculate_age(birth_date):
    today = date.today()
    age   = today.year - birth_date.year
    # 如果今年的生日还没到，年龄减 1
    if (today.month, today.day) < (birth_date.month, birth_date.day):
        age -= 1
    return age

birthday = date(1995, 8, 20)
print(f"年龄：{calculate_age(birthday)} 岁")

第四部分：os——操作系统接口

4.1 获取路径信息

import os

# 获取当前工作目录
print(os.getcwd())            # 如：C:UsersAdministratorDesktop

# 获取环境变量
print(os.environ.get("HOME"))         # Linux/Mac 家目录
print(os.environ.get("USERNAME"))     # Windows 用户名

# 路径拼接（推荐用 os.path.join，自动处理 / 和 ）
path = os.path.join("文件夹", "子文件夹", "文件.txt")
print(path)   # 文件夹子文件夹文件.txt（Windows）

4.2 文件和目录操作

import os

# 列出目录内容
files = os.listdir(".")         # 列出当前目录下所有文件和文件夹
print(files)

# 判断路径是否存在
print(os.path.exists("test_folder"))    # True 或 False

# 判断是文件还是目录
print(os.path.isfile("test.py"))        # 是文件？
print(os.path.isdir("test_folder"))     # 是目录？

# 创建目录
os.makedirs("new_folder/sub_folder", exist_ok=True)   # exist_ok=True：目录已存在不报错

# 删除空目录
# os.rmdir("empty_folder")

# 删除文件
# os.remove("test.txt")

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

4.3 路径操作

import os

path = "/home/user/documents/report.pdf"

print(os.path.basename(path))    # report.pdf（文件名）
print(os.path.dirname(path))     # /home/user/documents（目录部分）
print(os.path.splitext(path))    # ('/home/user/documents/report', '.pdf')

# 获取文件扩展名
name, ext = os.path.splitext("photo.jpg")
print(name)   # photo
print(ext)    # .jpg

# 获取文件大小（字节）
# print(os.path.getsize("myfile.txt"))

4.4 遍历目录（os.walk）

os.walk 可以递归遍历一个目录下的所有文件和子目录：

import os

# 遍历当前目录及所有子目录
for root, dirs, files in os.walk("."):
    # root：当前正在遍历的目录
    # dirs：当前目录下的子目录列表
    # files：当前目录下的文件列表
    print(f"目录：{root}")
    for filename in files:
        full_path = os.path.join(root, filename)
        print(f"  文件：{full_path}")

第五部分：pathlib——现代路径操作（推荐）

pathlib 是 Python 3.4+ 引入的模块，比 os.path 更直观、更面向对象，推荐新手优先使用。

5.1 基本用法

from pathlib import Path

# 创建路径对象
p = Path(".")                    # 当前目录
p2 = Path("/home/user/docs")     # 绝对路径

# 路径拼接用 / 运算符（非常直观！）
config = Path("项目") / "配置" / "settings.json"
print(config)   # 项目配置settings.json

# 获取当前工作目录
print(Path.cwd())

# 获取家目录
print(Path.home())   # C:UsersAdministrator（Windows）

5.2 路径属性

from pathlib import Path

p = Path("/home/user/documents/report.pdf")

print(p.name)       # report.pdf（文件名含扩展名）
print(p.stem)       # report（文件名不含扩展名）
print(p.suffix)     # .pdf（扩展名）
print(p.parent)     # /home/user/documents（父目录）
print(p.parts)      # ('/', 'home', 'user', 'documents', 'report.pdf')

5.3 判断与操作

from pathlib import Path

p = Path("test_folder")

print(p.exists())    # 是否存在
print(p.is_file())   # 是否是文件
print(p.is_dir())    # 是否是目录

# 创建目录
p.mkdir(parents=True, exist_ok=True)

# 列出目录内容
for item in Path(".").iterdir():
    print(item)

# 递归查找所有 .py 文件
for py_file in Path(".").rglob("*.py"):
    print(py_file)

5.4 读写文件（pathlib 内置）

from pathlib import Path

p = Path("hello.txt")

# 写文件
p.write_text("你好，Python！", encoding="utf-8")

# 读文件
content = p.read_text(encoding="utf-8")
print(content)   # 你好，Python！

第六部分：math——数学函数

6.1 常用函数

import math

# 常数
print(math.pi)      # 3.141592653589793
print(math.e)       # 2.718281828459045
print(math.inf)     # inf（正无穷）

# 取整
print(math.floor(3.7))   # 3（向下取整）
print(math.ceil(3.2))    # 4（向上取整）

# 绝对值（math.fabs 返回浮点数，abs() 返回整数）
print(math.fabs(-5.5))   # 5.5

# 幂和根
print(math.sqrt(16))     # 4.0（平方根）
print(math.pow(2, 10))   # 1024.0（2 的 10 次方）

# 对数
print(math.log(100, 10)) # 2.0（以 10 为底）
print(math.log2(8))      # 3.0（以 2 为底）
print(math.log(math.e))  # 1.0（自然对数）

# 三角函数（参数是弧度）
print(math.sin(math.pi / 2))   # 1.0
print(math.cos(0))             # 1.0
print(math.degrees(math.pi))   # 180.0（弧度 → 角度）
print(math.radians(180))       # 3.14...（角度 → 弧度）

# 阶乘
print(math.factorial(5))  # 120（5! = 1×2×3×4×5）

# 最大公约数
print(math.gcd(36, 48))   # 12

6.2 实战：计算圆的属性

import math

def circle_info(radius):
    area      = math.pi * radius ** 2
    perimeter = 2 * math.pi * radius
    print(f"半径：{radius}")
    print(f"面积：{area:.4f}")
    print(f"周长：{perimeter:.4f}")

circle_info(5)
# 半径：5
# 面积：78.5398
# 周长：31.4159

第七部分：json——处理 JSON 数据

JSON（JavaScript Object Notation）是最常用的数据交换格式，Python 用 json 模块来处理它。

7.1 Python 数据 → JSON 字符串（序列化）

import json

data = {
    "name": "张三",
    "age": 25,
    "hobbies": ["读书", "跑步", "编程"],
    "address": {"city": "北京", "zip": "100000"},
    "active": True,
    "score": None
}

# 转成 JSON 字符串
json_str = json.dumps(data, ensure_ascii=False, indent=2)
#   ensure_ascii=False：允许中文（默认会把中文转义）
#   indent=2：缩进 2 个空格，让输出更易读

print(json_str)

输出：

{
  "name": "张三",
  "age": 25,
  "hobbies": ["读书", "跑步", "编程"],
  "address": {"city": "北京", "zip": "100000"},
  "active": true,
  "score": null
}

7.2 JSON 字符串 → Python 数据（反序列化）

import json

json_str = '{"name": "李四", "age": 30, "scores": [85, 92, 78]}'

# JSON 字符串 → Python 字典
data = json.loads(json_str)
print(data)           # {'name': '李四', 'age': 30, 'scores': [85, 92, 78]}
print(data["name"])   # 李四
print(data["scores"]) # [85, 92, 78]

7.3 读写 JSON 文件

import json

# 写入 JSON 文件
data = {"name": "王五", "age": 22, "city": "上海"}

with open("user.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

print("已写入 user.json")

# 读取 JSON 文件
with open("user.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)

print(loaded)           # {'name': '王五', 'age': 22, 'city': '上海'}
print(loaded["city"])   # 上海

7.4 Python 和 JSON 数据类型对照

Python	JSON
`dict`	`object {}`
`list`、`tuple`	`array []`
`str`	`string ""`
`int`、`float`	`number`
`True` / `False`	`true` / `false`
`None`	`null`

第八部分：collections——高级数据结构

8.1 Counter——计数器

快速统计元素出现次数：

from collections import Counter

# 统计字符串中每个字符出现的次数
text = "hello world"
count = Counter(text)
print(count)
# Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# 统计列表中元素出现次数
words = ["苹果", "香蕉", "苹果", "橙子", "香蕉", "苹果"]
count = Counter(words)
print(count)
# Counter({'苹果': 3, '香蕉': 2, '橙子': 1})

# 最常见的 2 个
print(count.most_common(2))
# [('苹果', 3), ('香蕉', 2)]

# 直接访问某个元素的计数
print(count["苹果"])   # 3
print(count["芒果"])   # 0（不存在返回 0，不报错）

8.2 defaultdict——带默认值的字典

普通字典访问不存在的键会报 KeyError；defaultdict 会自动创建默认值：

from collections import defaultdict

# defaultdict(list)：不存在的键自动初始化为空列表
students = defaultdict(list)

students["数学"].append("张三")
students["数学"].append("李四")
students["英语"].append("王五")

print(dict(students))
# {'数学': ['张三', '李四'], '英语': ['王五']}

# 普通字典会报错
normal = {}
# normal["数学"].append("张三")   # KeyError!

# defaultdict(int)：不存在的键自动初始化为 0
word_count = defaultdict(int)
sentence = "the cat sat on the mat the cat"
for word in sentence.split():
    word_count[word] += 1   # 不存在时自动从 0 开始

print(dict(word_count))
# {'the': 3, 'cat': 2, 'sat': 1, 'on': 1, 'mat': 1}

8.3 deque——双端队列

list 在头部插入/删除很慢（O(n)）；deque 在两端插入/删除都很快（O(1)）：

from collections import deque

dq = deque([1, 2, 3])

# 右端操作（和 list 一样）
dq.append(4)        # [1, 2, 3, 4]
dq.pop()            # 取出 4，剩 [1, 2, 3]

# 左端操作（list 这么做会很慢，deque 很快）
dq.appendleft(0)    # [0, 1, 2, 3]
dq.popleft()        # 取出 0，剩 [1, 2, 3]

# 旋转（正数右移，负数左移）
dq.rotate(1)        # [3, 1, 2]
dq.rotate(-1)       # [1, 2, 3]

# 限制长度（超出时自动从另一端丢弃）
history = deque(maxlen=3)
for i in range(6):
    history.append(i)
    print(list(history))
# [0]
# [0, 1]
# [0, 1, 2]
# [1, 2, 3]   ← 超出 3 个，自动丢掉最老的
# [2, 3, 4]
# [3, 4, 5]

8.4 namedtuple——带名字的元组

普通元组要靠下标访问，不直观；namedtuple 给每个位置起个名字：

from collections import namedtuple

# 定义一个带名字的元组类型
Point   = namedtuple("Point",   ["x", "y"])
Student = namedtuple("Student", ["name", "age", "score"])

# 创建实例
p = Point(3, 4)
s = Student("张三", 18, 95)

# 既可以用名字访问，也可以用下标访问
print(p.x, p.y)          # 3 4
print(p[0], p[1])        # 3 4

print(s.name, s.score)   # 张三 95

# 不可修改（和元组一样）
# s.name = "李四"  # AttributeError!

# 转为字典
print(s._asdict())   # {'name': '张三', 'age': 18, 'score': 95}

第九部分：re——正则表达式

正则表达式是一种用来匹配和处理字符串的强大工具。

9.1 基本匹配

import re

text = "我的手机号是 13812345678，备用号码 15987654321"

# re.search：在字符串中搜索（找到第一个匹配）
match = re.search(r"1[3-9]d{9}", text)   # 匹配手机号
if match:
    print("找到手机号：", match.group())  # 13812345678

# re.findall：找出所有匹配
phones = re.findall(r"1[3-9]d{9}", text)
print("所有手机号：", phones)   # ['13812345678', '15987654321']

9.2 常用正则符号速查

符号	含义	例子
`.`	任意一个字符（除换行）	`a.c` 匹配 `abc`、`a1c`
`d`	数字（0-9）	`dd` 匹配 `12`
`w`	字母/数字/下划线	`w+` 匹配 `hello_123`
`s`	空白字符（空格、Tab等）	`asb` 匹配 `a b`
`^`	字符串开头	`^你好` 匹配以”你好”开头
`$`	字符串结尾	`结束$` 匹配以”结束”结尾
`*`	前面的字符 0 次或多次	`ab*` 匹配 `a`、`ab`、`abbb`
`+`	前面的字符 1 次或多次	`ab+` 匹配 `ab`、`abbb`
`?`	前面的字符 0 次或 1 次	`ab?` 匹配 `a`、`ab`
`{n}`	恰好 n 次	`d{4}` 匹配 4 个数字
`{n,m}`	n 到 m 次	`d{2,4}` 匹配 2-4 个数字
`[abc]`	a、b 或 c 之一	`[aeiou]` 匹配一个元音字母
`[^abc]`	不是 a、b、c	`[^0-9]` 匹配非数字字符
`(ab)`	分组	`(ab)+` 匹配 `ab`、`ababab`

9.3 替换和分割

import re

text = "电话：010-12345678，手机：138-1234-5678"

# re.sub：替换匹配的内容
clean = re.sub(r"[-]", "", text)   # 删除所有横线
print(clean)   # 电话：01012345678，手机：13812345678

# re.split：按正则分割
data = "苹果，香蕉；橙子 葡萄"
fruits = re.split(r"[，；s]+", data)   # 按中文逗号、分号、空格分割
print(fruits)   # ['苹果', '香蕉', '橙子', '葡萄']

9.4 实战：验证邮箱格式

import re

def is_valid_email(email):
    pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$"
    return bool(re.match(pattern, email))

emails = [
    "user@example.com",
    "invalid-email",
    "test@.com",
    "hello@world.org",
    "张三@example.com",
]

for e in emails:
    result = "✓ 合法" if is_valid_email(e) else "✗ 非法"
    print(f"{e:30} {result}")

第十部分：time——时间工具

10.1 常用函数

import time

# 获取当前时间戳（1970年1月1日至今的秒数）
ts = time.time()
print(ts)   # 如：1710123456.789

# 让程序暂停 N 秒
print("开始等待...")
time.sleep(2)   # 暂停 2 秒
print("等待结束！")

# 格式化当前时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))   # 2024-03-11 14:30:25

# 测量代码运行时间（推荐用 perf_counter，精度更高）
start = time.perf_counter()

total = sum(range(1_000_000))

end = time.perf_counter()
print(f"运行时间：{end - start:.6f} 秒")

10.2 实战：计时装饰器

import time

def timer(func):
    """计时装饰器：自动测量函数运行时间"""
    def wrapper(*args, **kwargs):
        start  = time.perf_counter()
        result = func(*args, **kwargs)
        end    = time.perf_counter()
        print(f"{func.__name__} 运行时间：{end - start:.6f} 秒")
        return result
    return wrapper

@timer
def slow_function():
    total = 0
    for i in range(500_000):
        total += i
    return total

result = slow_function()
print(f"结果：{result}")

第十一部分：itertools——高效迭代工具

11.1 无限迭代器

import itertools

# count：从 n 开始无限计数
counter = itertools.count(1, 2)   # 从 1 开始，步长 2
for _ in range(5):
    print(next(counter), end=" ")  # 1 3 5 7 9

# cycle：无限循环一个序列
colors = itertools.cycle(["红", "绿", "蓝"])
for _ in range(7):
    print(next(colors), end=" ")   # 红 绿 蓝 红 绿 蓝 红

11.2 有限迭代器

import itertools

# chain：连接多个可迭代对象
result = list(itertools.chain([1, 2], [3, 4], [5]))
print(result)   # [1, 2, 3, 4, 5]

# islice：切片迭代器
result = list(itertools.islice(range(100), 5, 15, 2))
print(result)   # [5, 7, 9, 11, 13]（从下标5开始，步长2，共10个以内）

# zip_longest：按最长序列合并（不足的用 fillvalue 补）
a = [1, 2, 3]
b = ["a", "b"]
for pair in itertools.zip_longest(a, b, fillvalue="?"):
    print(pair)
# (1, 'a')
# (2, 'b')
# (3, '?')

11.3 排列与组合

import itertools

items = ["A", "B", "C"]

# 排列（有顺序）
print("排列（取2个）：")
for p in itertools.permutations(items, 2):
    print(p, end="  ")
# ('A', 'B')  ('A', 'C')  ('B', 'A')  ('B', 'C')  ('C', 'A')  ('C', 'B')

print()

# 组合（无顺序）
print("组合（取2个）：")
for c in itertools.combinations(items, 2):
    print(c, end="  ")
# ('A', 'B')  ('A', 'C')  ('B', 'C')

print()

# 笛卡尔积
print("笛卡尔积：")
for pair in itertools.product([1, 2], ["a", "b"]):
    print(pair, end="  ")
# (1, 'a')  (1, 'b')  (2, 'a')  (2, 'b')

第十二部分：string——字符串工具

import string

# 预定义的字符集合
print(string.ascii_letters)   # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_lowercase) # abcdefghijklmnopqrstuvwxyz
print(string.ascii_uppercase) # ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.digits)          # 0123456789
print(string.punctuation)     # !"#$%&'()*+,-./:;<=>?@[]^_`{|}~

# 实战：生成随机密码
import random

def generate_password(length=12):
    chars    = string.ascii_letters + string.digits + string.punctuation
    password = "".join(random.choice(chars) for _ in range(length))
    return password

print("随机密码：", generate_password(16))

# 字符串模板（Template）
from string import Template

t = Template("你好，$name！你的成绩是 $score 分。")
msg = t.substitute(name="张三", score=95)
print(msg)   # 你好，张三！你的成绩是 95 分。

第十三部分：sys——系统相关

13.1 常用属性和函数

import sys

# Python 版本
print(sys.version)          # 如：3.12.0 (main, ...) ...
print(sys.version_info)     # sys.version_info(major=3, minor=12, ...)

# 当前平台
print(sys.platform)         # win32（Windows）、linux、darwin（Mac）

# 模块搜索路径（Python 去哪里找模块）
print(sys.path)             # 一个路径列表

# 命令行参数
# 运行：python script.py hello world
print(sys.argv)             # ['script.py', 'hello', 'world']

# 退出程序
# sys.exit(0)   # 0 表示正常退出，非 0 表示异常退出

# 最大整数（Python 3 中整数没有大小限制，这里是遗留信息）
print(sys.maxsize)          # 9223372036854775807

# 标准输入输出
sys.stdout.write("直接写到标准输出n")

13.2 实战：跨平台判断

import sys

if sys.platform == "win32":
    print("当前是 Windows 系统")
    clear_cmd = "cls"
elif sys.platform == "darwin":
    print("当前是 macOS 系统")
    clear_cmd = "clear"
else:
    print("当前是 Linux 系统")
    clear_cmd = "clear"

第十四部分：常见陷阱与注意事项

14.1 导入模块时不要重名

# 不要创建 random.py、os.py、math.py 等与标准库同名的文件
# 否则导入的是你自己的文件，而不是标准库

14.2 random 不是真随机（密码场景用 secrets）

import random
import secrets

# random 是伪随机，用于模拟、游戏等场景
print(random.randint(1, 100))

# 密码、Token 等安全场景要用 secrets
print(secrets.randbelow(100))            # 安全随机整数
print(secrets.token_hex(16))             # 安全随机十六进制字符串
print(secrets.token_urlsafe(16))         # 安全随机 URL 安全字符串

14.3 datetime 的时区问题

from datetime import datetime, timezone, timedelta

# 不带时区的时间（naive）
now_naive = datetime.now()

# 带时区的时间（aware）
now_utc = datetime.now(timezone.utc)

# 中国时区（UTC+8）
tz_china = timezone(timedelta(hours=8))
now_china = datetime.now(tz_china)
print(now_china.strftime("%Y-%m-%d %H:%M:%S %Z"))

14.4 json 只支持基本类型，不支持 datetime、自定义类

import json
from datetime import datetime

data = {"time": datetime.now()}
# json.dumps(data)   # TypeError: Object of type datetime is not JSON serializable

# 解决方案：先转成字符串
data = {"time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
print(json.dumps(data))   # {"time": "2024-03-11 14:30:25"}

14.5 re 的原始字符串

正则表达式里大量使用，建议始终用原始字符串 r"..." 避免歧义：

import re

# 不用原始字符串：d 要写成 \d
pattern1 = "\d+"

# 用原始字符串：直接写 d（推荐）
pattern2 = r"d+"

text = "2024年3月"
print(re.findall(pattern1, text))   # ['2024', '3']
print(re.findall(pattern2, text))   # ['2024', '3']

第十五部分：小结——常用模块速查表

模块	主要用途	最常用的函数/类
`random`	随机数和随机选取	`randint`、`choice`、`shuffle`、`sample`
`datetime`	日期时间处理	`datetime.now()`、`strftime`、`strptime`、`timedelta`
`os`	操作系统接口、文件路径	`getcwd`、`listdir`、`makedirs`、`path.join`、`walk`
`pathlib`	现代路径操作（推荐）	`Path`、`/` 拼接、`read_text`、`write_text`、`rglob`
`math`	数学函数	`sqrt`、`floor`、`ceil`、`pi`、`factorial`、`gcd`
`json`	JSON 数据处理	`dumps`、`loads`、`dump`、`load`
`collections`	高级数据结构	`Counter`、`defaultdict`、`deque`、`namedtuple`
`re`	正则表达式	`search`、`findall`、`sub`、`split`、`match`
`time`	时间和计时	`time()`、`sleep`、`strftime`、`perf_counter`
`itertools`	高效迭代	`chain`、`product`、`permutations`、`combinations`
`string`	字符串常量和模板	`ascii_letters`、`digits`、`Template`
`sys`	系统信息和控制	`version`、`platform`、`argv`、`exit`

访问数: 13