Python 代码加速运行的 8 种实用技巧

通过 from ... import ... 语句将函数导入为局部变量，消除属性访问。

# 第一次优化：导入函数
from math import sqrt

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(sqrt(i))
    return result

进一步，将列表的 append 方法也赋值给局部变量，彻底消除循环内的属性查找。

# 推荐写法：缓存常用方法
import math

def computeSqrt(size: int):
    result = []
    append = result.append
    sqrt = math.sqrt
    for i in range(size):
        append(sqrt(i))
    return result

2.2 避免类内属性访问

在类的方法中，访问 self._value 同样比访问局部变量慢。对于高频访问的实例属性，可将其缓存到局部变量中。

# 推荐写法：缓存实例属性
import math
from typing import List

class DemoClass:
    def __init__(self, value: int):
        self._value = value

    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        value = self._value  # 缓存到局部变量
        for _ in range(size):
            append(sqrt(value))
        return result

3. 避免不必要的抽象

装饰器、属性访问器（property）、描述器等抽象层虽然提升了代码的可读性和安全性，但也会增加运行时开销。在性能敏感的场景下，应简化结构。

# 不推荐写法：使用 property 包装简单属性
class DemoClass:
    def __init__(self, value: int):
        self.value = value

    @property
    def value(self) -> int:
        return self._value

    @value.setter
    def value(self, x: int):
        self._value = x

直接使用普通属性通常能获得更好的性能。

# 推荐写法：直接访问属性
class DemoClass:
    def __init__(self, value: int):
        self.value = value

4. 避免数据复制

4.1 避免无意义的数据复制

创建中间数据结构会增加内存分配和拷贝开销。尽量直接在迭代过程中处理数据。

# 不推荐写法：创建不必要的中间列表
def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        value_list = [x for x in value]
        square_list = [x * x for x in value_list]

# 推荐写法：直接推导
import time

def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        square_list = [x * x for x in value]

4.2 交换值时不使用中间变量

Python 支持元组解包，可以直接交换变量，无需临时变量。

# 推荐写法：元组解包
a, b = b, a

4.3 字符串拼接用 join 而不是 +

字符串是不可变对象。使用 + 拼接时，每次操作都会创建新对象并复制内容。join() 会预先计算总长度，一次性分配内存。

# 不推荐写法：循环拼接
result = ''
for s in string_list:
    result += s

# 推荐写法：使用 join
result = ''.join(string_list)

5. 利用 if 条件的短路特性

在布尔表达式中，Python 会按顺序求值。对于 and，若前一项为假则不再计算后一项；对于 or，若前一项为真则不再计算后一项。合理排序条件可减少计算量。

# 推荐写法：先判断高概率条件
if str_i[-1] == '.' and str_i in abbreviations:
    result += str_i

6. 循环优化

6.1 用 for 循环代替 while 循环

Python 的 for 循环基于迭代器协议实现，底层由 C 优化，通常比手动管理索引的 while 循环更快。

# 推荐写法：使用 for
for i in range(size):
    sum_ += i

6.2 使用隐式 for 循环代替显式 for 循环

利用内置函数（如 sum, map, filter）通常能发挥 C 扩展的优势。

# 推荐写法：内置函数
return sum(range(size))

6.3 减少内层 for 循环的计算

将不随内层循环变化的计算提取到外层循环之外。

# 推荐写法：循环外提
for x in range(size):
    sqrt_x = sqrt(x)
    for y in range(size):
        z = sqrt_x + sqrt(y)

7. 使用 numba.jit

Numba 是一个 JIT 编译器，可以将 Python 数值计算函数编译为机器码执行，大幅提升数值密集型代码的性能。

import numba

@numba.jit(nopython=True)
def computeSum(size: float) -> int:
    total = 0
    for i in range(int(size)):
        total += i
    return total

8. 选择合适的数据结构

Python 内置数据结构底层多为 C 实现，效率较高。根据场景选择正确的结构至关重要。

• List vs Deque: list 适合随机访问，但在两端频繁插入删除效率低。collections.deque 支持 O(1) 复杂度的两端操作。
• 查找优化: 若需频繁查找有序元素，可使用 bisect 模块维护有序列表并进行二分查找。
• 极值查找: 获取最小值或最大值时，可使用 heapq 模块构建堆，使获取极值的时间复杂度降为 O(1)。

总结

性能优化是一个系统工程，需要结合具体场景权衡。建议遵循以下流程：

1. 编写正确且可读的代码。
2. 使用性能分析工具定位瓶颈。
3. 针对热点代码应用上述优化技巧。
4. 验证优化效果，确保未牺牲代码质量。

通过合理运用这些技巧，可以在不改变业务逻辑的前提下，显著提升 Python 程序的运行效率。