Post

Python 常用模块

常用的 Python 模块(持续更新)

Posted
By Ding Yumeng
18 min read
Python 常用模块

Python 常用模块

os 模块

os 模块是 Python 标准库中用于与操作系统进行交互的模块，它提供了许多强大的功能，可以帮助你完成文件和目录的操作、获取环境信息、执行系统命令等任务。下面是 os 模块常用的功能分类：

路径操作（结合 os.path 使用）

  • os.path.join()：拼接路径
  • os.path.exists()：判断路径是否存在
  • os.path.isdir() / os.path.isfile()：判断是否是目录/文件
  • os.path.abspath()：获取绝对路径
  • os.path.basename()：获取路径的文件名部分
  • os.path.dirname()：获取路径的目录部分
  • os.path.splitext()：分离文件名和扩展名

文件与目录操作

  • os.listdir(path)：列出目录下的所有文件和文件夹
  • os.mkdir(path) / os.makedirs(path)：创建目录（makedirs 可递归创建多层目录）
  • os.remove(path)：删除文件
  • os.rmdir(path) / os.removedirs(path)：删除目录（removedirs 可递归删除空目录）
  • os.rename(src, dst)：重命名文件或目录
  • os.stat(path)：获取文件或目录的状态信息（如大小、权限、修改时间等）

运行系统命令

  • os.system(command)：运行系统命令（返回命令的退出状态码）
  • os.popen(command)：执行命令并读取输出（不推荐，建议用 subprocess）

环境变量

  • os.environ：环境变量的字典对象
  • os.getenv(key, default=None)：获取指定环境变量

操作系统信息

  • os.name：返回操作系统类型（如 'posix', 'nt'）
  • os.uname()：获取系统信息（仅类 Unix 系统支持）
  • os.getcwd()：获取当前工作目录
  • os.chdir(path)：更改当前工作目录

sys 模块

sys 模块是 Python 标准库中与 Python 解释器进行交互的重要模块，主要用于访问与 Python 解释器相关的变量和函数，比如命令行参数、模块路径、标准输入输出、系统退出等。

命令行参数

sys.argv：以列表形式获取命令行参数，argv[0] 是脚本名。

1
2
3

import sys
print(sys.argv)  # 比如运行 python test.py arg1 arg2
# 输出：['test.py', 'arg1', 'arg2']

退出程序

sys.exit([arg])：退出程序，arg 可以是整数（表示退出状态码）或字符串（表示错误信息）。

1
2

sys.exit(0)  # 正常退出
sys.exit("发生错误，退出程序")  # 错误退出并输出信息

模块路径

sys.path：模块的搜索路径列表，等价于 PYTHONPATH 环境变量 + 当前目录 + 安装目录等。

1
2

import sys
print(sys.path)

你可以通过 sys.path.append("路径") 添加自定义模块路径。

datetime 模块

Python有一个名为datetime的模块，用于处理日期和时间。

获取当前时间

1
2
3

from datetime import datetime
current_time = datetime.now()
print(current_time)  # 输出当前时间

格式化日期时间

1
2

formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_time)  # 输出格式化后的时间
  • %Y -年[0001，…，2018，2019，…，9999]
  • %m -月[01，02，…，11，12]
  • %d -天[01，02，…，30，31]
  • %H -小时[00，01，…，22，23]
  • %M -分钟[00，01，…，58，59]
  • %S -秒[00，01，…，58，59]

re 模块

re 模块是 Python 用于处理正则表达式（Regular Expression）的标准库，主要功能是用于字符串的模式匹配、搜索、提取、替换等操作。

功能方法说明
匹配re.match()从字符串开始位置匹配
搜索re.search()匹配第一个符合的子串
查找所有re.findall()找到所有匹配的内容，返回列表
迭代匹配re.finditer()找到所有匹配项，返回迭代器（Match对象）
替换re.sub()替换匹配的内容
分割re.split()根据正则规则分割字符串
编译re.compile()编译正则表达式为模式对象，提升效率

示例

1
2
3
4
5
6
7

import re

text = "邮箱是 test123@example.com，电话是 123-456-7890"

# 搜索邮箱
match = re.search(r'\w+@\w+\.\w+', text)
print(match.group())  # 输出：test123@example.com

常用正则表达式符号

符号含义  
.匹配任意字符（除换行符）  
^匹配开头  
$匹配结尾  
*匹配前一个字符0次或多次  
+匹配前一个字符1次或多次  
?匹配0次或1次  
{n}匹配n次  
{n,m}匹配n到m次  
[]匹配字符集合，如 [a-z]  
\d匹配数字，等价于 [0-9]  
\w匹配字母数字下划线  
\s匹配空白字符（空格、换行、制表符）  
`| `或，如 `abc | def`  

方法详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14

re.match(r'\d+', '123abc').group()  # 输出：'123'
# `re.match(pattern, string)` 只能从开头匹配
re.search(r'\d+', 'abc123xyz').group()  # 输出：'123'
# `re.search(pattern, string)`匹配第一个出现的位置
re.findall(r'\d+', 'a1b22c333')  # 输出：['1', '22', '333']
# `re.findall(pattern, string)`返回所有匹配项（列表）
re.sub(r'\d+', '#', 'a1b22c333')  # 输出：'a#b#c#'
# `re.sub(pattern, repl, string)`替换匹配的内容
re.split(r'\d+', 'a1b22c333')  # 输出：['a', 'b', 'c', '']
# `re.split(pattern, string)`按匹配结果分割字符串
pattern = re.compile(r'\d+')
result = pattern.findall('a1b22c333')
print(result)  # ['1', '22', '333']
# `re.compile(pattern)`编译正则表达式为模式对象

常用正则表达式示例

  • 匹配邮箱：r'\w+@\w+\.\w+'
  • 匹配手机号：r'1[3-9]\d{9}'
  • 匹配日期：r'\d{4}-\d{2}-\d{2}'
  • 匹配中文：r'[\u4e00-\u9fa5]+'

collections 模块

deque（双端队列）

deque 是一个双端队列，比 Python 内建的 list 在头尾操作更高效。

1
2
3
4
5
6
7
8
9
10
11
12
13

from collections import deque

# 创建一个双端队列
d = deque([1, 2, 3])

# 从队列的一端添加或删除元素
d.append(4)         # 在右侧添加
d.appendleft(0)     # 在左侧添加

d.pop()             # 从右侧删除并返回
d.popleft()         # 从左侧删除并返回

print(d)            # deque([0, 1, 2, 3])

defaultdict（带默认值的字典）

defaultdict 是 dict 的一个子类，可以为每个键自动提供默认值，而不需要显式判断 key in dict。

1
2
3
4
5
6
7
8
9

from collections import defaultdict

# 创建一个默认值为 0 的字典
d = defaultdict(int)

d['apple'] += 1
d['banana'] += 2

print(d)  # defaultdict(<class 'int'>, {'apple': 1, 'banana': 2})

Counter（计数器）

Counter 是一个用于计数元素出现频率的工具，继承自 dict，键为元素，值为计数。

1
2
3
4
5
6
7
8
9

from collections import Counter

words = ['apple', 'banana', 'apple', 'orange', 'banana']
counter = Counter(words)

print(counter)  # Counter({'apple': 2, 'banana': 2, 'orange': 1})

# 获取最常见的元素
print(counter.most_common(1))  # [('apple', 2)]

namedtuple（具名元组）

namedtuple 是一个工厂函数，用于创建具名元组，提供更好的可读性。

1
2
3
4

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)  # 输出：10 20

ChainMap（链式映射）

ChainMap 是一个将多个字典或映射组合在一起的容器，可以在多个字典中查找键。

1
2
3
4
5
6

from collections import ChainMap
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
chain = ChainMap(dict1, dict2)
print(chain['b'])  # 输出：2（查找 dict1 中的 'b'）
print(chain['c'])  # 输出：4（查找 dict2 中的 'c'）

functools 模块

lru_cache（LRU 缓存装饰器）

lru_cache 可以缓存函数的结果，避免重复计算，提高性能。

1
2
3
4
5
6
7
8
9

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(10))  # 55

partial（偏函数）

partial 用于固定函数的某些参数，返回一个新的函数。

1
2
3
4
5

from functools import partial
def multiply(x, y):
    return x * y
double = partial(multiply, 2)  # 固定第一个参数为 2
print(double(5))  # 输出：10

itertools 模块

chain（连接多个迭代器）

串联多个迭代器为一个迭代器。

1
2
3
4
5
6

from itertools import chain

a = [1, 2]
b = [3, 4]
for x in chain(a, b):
    print(x)  # 1 2 3 4

cycle（无限循环）

无限循环一个序列。

1
2
3
4
5
6
7
8
9

from itertools import cycle

count = 0
for x in cycle([1, 2, 3]):
    print(x)
    count += 1
    if count == 6:
        break
# 输出：1 2 3 1 2 3

combinations（组合）

从序列中生成所有指定长度的组合。

1
2
3
4
5
6

from itertools import combinations

items = ['a', 'b', 'c']
for combo in combinations(items, 2):
    print(combo)
# ('a', 'b'), ('a', 'c'), ('b', 'c')

product（笛卡尔积）

计算多个序列的笛卡尔积。

1
2
3
4
5

from itertools import product

for p in product([1, 2], ['a', 'b']):
    print(p)
# (1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')

dataclasses 模块

dataclasses 模块是 Python 3.7 引入的标准库，用于简化类的编写，特别是用于创建数据模型类。使用 @dataclass 装饰器，可以自动为类生成常用的魔术方法。

基本用法

1
2
3
4
5
6
7
8
9

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

p = Person("小明", 18)
print(p)  # 输出：Person(name='小明', age=18)

相当于自动帮你写了 __init__() 和 __repr__() 等方法。

常用参数选项

参数含义
init是否生成 __init__()（默认 True）
repr是否生成 __repr__()（默认 True）
eq是否生成 __eq__()（默认 True）
order是否生成排序方法（<, <=, >…）
frozen是否将实例变为不可变对象（类似元组）
slotsPython 3.10+：是否启用 __slots__（节省内存）
1
2
3
4
5
6
7

@dataclass(frozen=True)
class Point:
    x: int
    y: int

p = Point(1, 2)
# p.x = 10  # 报错：FrozenInstanceError

默认值

默认值是列表、字典等，用field(default_factory=···),不要直接用 scores: list = []，因为会造成所有实例共享一个列表！

1
2
3
4
5
6

from dataclasses import field

@dataclass
class Student:
    name: str
    scores: list[int] = field(default_factory=list)

tqdm 模块

tqdm 是一个非常实用的 Python 进度条库，名字来源于阿拉伯语“taqaddum（تقدّم）”意思是“进展”。它可以非常轻松地在终端、Jupyter Notebook 等环境中为循环添加实时进度条显示。

基本用法

1
2
3
4

from tqdm import tqdm
for i in tqdm(range(100)):
    # 模拟一些工作
    pass

高级用法

  • 自定义描述：可以在进度条前添加描述信息。
1
2

for i in tqdm(range(100), desc="Processing"):
    pass
  • 嵌套进度条：可以使用 tqdm 的 tqdm 作为迭代器的嵌套。
1
2
3
4
5

from tqdm import tqdm
for i in tqdm(range(5), desc="Outer Loop"):
    for j in tqdm(range(10), desc="Inner Loop", leave=False):
        # 模拟一些工作
        pass
  • 动态更新：可以在循环中动态更新进度条的描述。
1
2
3
4
5
6
7
8

from tqdm import tqdm
from time import sleep
from random import random

loop = tqdm(range(100), desc="Processing")
for i in loop:
    sleep(0.1)
    loop.set_postfix({'acc': f"{random():.2f}"})

logging 模块

Python 的 logging 模块是一个内置的日志记录模块，用于追踪和调试程序运行过程中的信息。比 print() 更加灵活、可控，适合生产环境使用。

基本用法

1
2
3
4
5
6
7

import logging

logging.debug("这是调试信息")
logging.info("这是普通信息")
logging.warning("这是警告信息")
logging.error("这是错误信息")
logging.critical("这是严重错误信息")

默认情况下，logging 的日志级别是 WARNING，也就是说，只有 warning、error 和 critical 会输出。

设置日志级别和格式

1
2
3
4

import logging
logging.basicConfig(level=logging.DEBUG,  # 设置日志级别
                    format='%(asctime)s - %(levelname)s - %(message)s')  #设置日志格式
logging.debug("这是调试信息")

常用的日志级别（按严重性升序）：

  • DEBUG：调试信息
  • INFO：普通信息
  • WARNING：警告（默认级别）
  • ERROR：错误
  • CRITICAL：严重错误
占位符含义
%(asctime)s时间戳
%(name)s日志器名称
%(levelname)s日志级别
%(message)s日志信息主体
%(filename)s脚本文件名
%(lineno)d行号
%(module)s模块名
%(funcName)s函数名

记录日志到文件

1
2
3
4
5
6

logging.basicConfig(
    filename='app.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logging.info("这条信息将被记录到文件中")

使用Logger对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 控制台输出
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# 文件输出
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.WARNING)

# 设置格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# 添加 handler
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# 示例
logger.debug('调试信息')
logger.info('普通信息')
logger.warning('警告信息')
logger.error('错误信息')

argparse 模块

argparse 模块是 Python 标准库中用于处理命令行参数的模块，它提供了一个简单的方式来定义和解析命令行参数。

基本用法

1
2
3
4
5
6
7
8
9

import argparse

parser = argparse.ArgumentParser(description="这是一个示例程序")
parser.add_argument('--name', type=str, help='你的名字')
parser.add_argument('--age', type=int, help='你的年龄')

args = parser.parse_args()

print(f"你好，{args.name}，你今年 {args.age} 岁。")

运行示例

1
2

python example.py --name 小明 --age 18
# 输出：你好，小明，你今年 18 岁。
参数名说明
name or flags参数名（如 --name）或位置参数（如 filename）
help参数说明文字
type参数类型，如 int、str
default默认值
required是否必填（仅限可选参数）
choices限定值范围
action特殊行为，如 store_true 用于布尔开关
Python
python
This post is licensed under CC BY 4.0 by the author.