本文目录导读：
- 利用 和 进行序列解包与函数参数解构
- 列表/字典/集合推导式 (Comprehension)
- 使用
collections模块简化数据结构操作 - 生成器表达式 (Generator Expression) 避免内存暴涨
- 装饰器 (Decorator) 实现 AOP 和非侵入式功能增强
- 使用
with语句管理资源 (上下文管理器) - itertools 模块简化迭代逻辑
- 使用
f-string格式化字符串 (Python 3.6+) - 高效编码的核心原则
Python高效编码的核心在于简洁、可读、利用语言特性，以下是一些能显著提升效率、减少冗余代码的经典案例，涵盖数据结构、函数式编程、装饰器等进阶用法。
利用 和 进行序列解包与函数参数解构
场景：合并列表、字典，或从函数返回多个值。
# 传统方式 (冗长)
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2 # [1,2,3,4,5,6]
# 高效方式：使用 * 解包 (适合任意可迭代对象)
merged_list = [*list1, *list2] # [1,2,3,4,5,6]
# 字典合并 (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged_dict = {**dict1, **dict2} # {'a':1, 'b':2, 'c':3, 'd':4}
# 或者使用 | 运算符 (Python 3.9+)
merged_dict = dict1 | dict2
# 函数参数解包
def func(a, b, c):
return a + b + c
params_list = [1, 2, 3]
params_dict = {'a': 1, 'b': 2, 'c': 3}
print(func(*params_list)) # 6
print(func(**params_dict)) # 6
列表/字典/集合推导式 (Comprehension)
场景：从现有迭代器创建新列表、字典或集合，避免手动循环和 append。
# 传统方式 (慢，且多行)
squares = []
for x in range(10):
squares.append(x ** 2)
# 高效方式：列表推导
squares = [x ** 2 for x in range(10)] # [0,1,4,9,...]
# 带条件的推导式
evens = [x for x in range(20) if x % 2 == 0] # [0,2,4,...]
# 字典推导式
squared_dict = {x: x ** 2 for x in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16}
# 集合推导式 (自动去重)
unique_evens = {x for x in [2, 2, 4, 4, 6, 8]} # {2, 4, 6, 8}
# 嵌套推导式 (展平二维列表)
matrix = [[1,2], [3,4], [5,6]]
flat = [num for row in matrix for num in row] # [1,2,3,4,5,6]
使用 collections 模块简化数据结构操作
场景：统计元素出现次数、带默认值的字典、双端队列。
from collections import Counter, defaultdict, deque
# 1. Counter：一行搞定元素频率统计
text = "hello world"
counter = Counter(text) # Counter({'l':3, 'o':2, ...})
print(counter.most_common(1)) # [('l', 3)] 出现最多的元素
# 2. defaultdict：避免手动检查 key 是否存在
original_dict = {}
for char in "hello":
if char not in original_dict:
original_dict[char] = 0
original_dict[char] += 1
# 使用 defaultdict (自动初始化)
from collections import defaultdict
count_dict = defaultdict(int) # 默认值为0
for char in "hello":
count_dict[char] += 1
# 3. deque：高效的双端队列 (比列表在两端插入/删除快)
d = deque([1, 2, 3])
d.appendleft(0) # deque([0,1,2,3])
d.pop() # 3
d.popleft() # 0
生成器表达式 (Generator Expression) 避免内存暴涨
场景：处理大规模数据流（文件、无限序列）时，不一次性生成所有元素。
# 列表推导会生成完整列表，占用内存
sum_of_squares = sum([x ** 2 for x in range(1000000)]) # 立即创建大列表
# 生成器表达式 (无方括号) - 惰性求值，按需生成
sum_of_squares = sum(x ** 2 for x in range(1000000)) # 几乎不占内存
# 适用于文件逐行处理
with open('large_file.txt') as f:
lines = (line.strip() for line in f) # 生成器，不加载全部行
for line in lines:
process(line)
装饰器 (Decorator) 实现 AOP 和非侵入式功能增强
场景：日志记录、性能计时、权限校验、缓存。
import time
from functools import wraps
# 定义一个计时装饰器
def timer(func):
@wraps(func) # 保留原函数的元信息 (如 __name__, __doc__)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
end = time.perf_counter()
print(f"{func.__name__} took {end - start:.6f}s")
return result
return wrapper
# 使用装饰器
@timer
def slow_function(n):
time.sleep(n)
return n * 2
slow_function(1) # 输出: slow_function took 1.000xxx s
使用 with 语句管理资源 (上下文管理器)
场景：安全地打开文件、锁、数据库连接，自动释放资源。
# 传统方式 (需手动 close)
f = open('data.txt', 'r')
try:
data = f.read()
finally:
f.close()
# 高效方式：with 语句
with open('data.txt', 'r') as f:
data = f.read() # 文件自动关闭，即使发生异常
# 自定义上下文管理器 (例如控制锁)
from contextlib import contextmanager
@contextmanager
def simple_locker():
print("获取锁")
yield
print("释放锁")
with simple_locker():
print("执行关键操作")
# 输出: 获取锁 -> 执行关键操作 -> 释放锁
itertools 模块简化迭代逻辑
场景：排列组合、无限迭代、分组、链式操作。
from itertools import chain, combinations, cycle, groupby
# 1. chain：合并多个迭代器为一个
list1 = [1, 2]
list2 = [3, 4]
list3 = [5, 6]
combined = list(chain(list1, list2, list3)) # [1,2,3,4,5,6]
# 2. combinations：生成所有组合 (无重复)
for combo in combinations([1, 2, 3], 2):
print(combo) # (1,2), (1,3), (2,3)
# 3. groupby：分组连续相同元素 (需排序)
data = [1, 1, 2, 2, 2, 3]
for key, group in groupby(data):
print(key, list(group)) # 1 [1,1], 2 [2,2,2], 3 [3]
使用 f-string 格式化字符串 (Python 3.6+)
场景：变量插值、表达式计算、格式化数字。
name = "Alice"
age = 30
height = 1.75
# 传统方式 (% 或 format)
print("My name is %s, age %d" % (name, age))
print("My name is {}, age {}".format(name, age))
# 高效方式：f-string (最简洁，最快)
print(f"My name is {name}, age {age}")
# 支持表达式
print(f"Next year, I'll be {age + 1} years old")
# 格式化数字
pi = 3.1415926
print(f"Pi is {pi:.2f}") # 3.14
print(f"Percent: {0.25:.2%}") # 25.00%
高效编码的核心原则
- 利用语言内置
collections,itertools,functools—— 避免重复造轮子。 - 使用推导式和生成器 —— 替代手动循环和
append。 - 解包和上下文管理器 —— 减少临时变量和资源泄漏风险。
- 装饰器实现横切关注点 —— 代码复用，分离核心逻辑与非功能需求。
- *f-string 和 `args, kwargs` —— 让代码更清晰、更动态。
这些案例不仅让代码更短、更快，也提高了可维护性，是 Python 开发者应该熟练掌握的“高效编码武器”。
标签： 高效编码