Python代码性能提升的十大实用技巧

在飞速发展的软件开发领域，Python凭借其简洁性、可读性和多功能性，已然确立了其作为主流编程语言的地位。它支撑着从Web开发到人工智能和数据工程等广泛的应用。不过，在其优雅的语法背后，潜藏着一个不容忽视的挑战：性能瓶颈。这些瓶颈可能将原本高效的脚本转变为明显迟缓的处理过程。

无论你的任务是处理大型数据集、开发实时系统，还是优化计算效率，提升Python代码的执行速度都将是决定性因素，助你取得更出色的成果。

本文将深入探讨10个经过严格检验的性能增强策略。这些策略充分利用了Python的内置功能、高效数据结构和底层优化技术。它们提供了实用的方法，可以在不牺牲Python特有的清晰度和优雅性的前提下，加速代码执行。通过实际基准测试和示例代码的支持，本文将展示微小的改善如何带来可观的性能提升，协助开发者从熟练的实践者蜕变为高性能Python编程的真正专家。

让我们深入了解这些技巧，为你的Python技能注入“涡轮增压”！

一、利用集合（Set）进行成员资格测试，实现常数时间复杂度

当你需要检查一个元素是否存在于一个集合中时，使用列表（List）会超级低效，特别是当列表的规模不断增长时。列表的成员资格测试（如 x in some_list）需要逐个扫描每个元素，导致其时间复杂度为线性时间 。

代码对比与时间测量:

big_list = list(range(1000000))
big_set = set(big_list)
start = time.time()
print(999999 in big_list)
print(f"List lookup: {time.time() - start:.6f}s")


start = time.time()
print(999999 in big_set)
print(f"Set lookup: {time.time() - start:.6f}s")

时间测量结果:

列表查找: 约
集合查找: 约

相比之下，Python中的集合（Set）是作为哈希表实现的，这使得其查找操作的平均时间复杂度达到常数时间 。这意味着检查一个值是否存在于集合中会快得多，尤其是在处理大型数据集时。

对于过滤重复项、验证输入或跨集合引用元素等任务，集合的效率远远高于列表。它们不仅能加快成员资格测试，还能使求并集、交集和差集等操作变得更快、更简洁。

在对性能要求较高的代码中，通过将成员资格检查从列表切换到集合，你可以用最小的逻辑改动获得显著的速度提升。

二、避免不必要的对象复制，减少时间和内存开销

复制像列表、字典或数组这样的大型对象，会消耗大量的时间和内存。每次复制都会在内存中创建一个全新的对象，这会带来显著的开销，尤其是在处理大型数据集或在紧密循环中进行操作时。

因此，应尽可能选择就地（in-place）修改对象，而不是创建副本。这样做可以减少内存使用并提升性能，由于它避免了分配和填充新数据结构的开销。Python的许多内置数据结构都提供了就地修改的方法（例如 sort、append、update），从而无需进行复制。

代码对比与时间测量:

numbers = list(range(1000000))
def modify_list(lst):
    lst[0] = 999
    return lst
start = time.time()
result = modify_list(numbers)
print(f"In-place: {time.time() - start:.4f}s")


def copy_list(lst):
    new_lst = lst.copy()
    new_lst[0] = 999
    return new_lst
start = time.time()
result = copy_list(numbers)
print(f"Copy: {time.time() - start:.4f}s")

时间测量结果:

就地修改: 约
复制操作: 约

在对性能要求严格的代码中，关注何时以及如何复制对象可以带来显著的差异。通过使用引用和就地操作，你可以编写出更高效、更节省内存的代码，尤其是在处理大型或复杂数据结构时。

三、使用 slots 提高内存效率，优化实例属性访问

默认情况下，Python类将实例属性存储在一个动态字典（__dict__）中。虽然这提供了灵活性，但会带来内存开销和稍慢的属性访问速度。

使用 __slots__ 允许你显式声明一个固定的类属性集合。这消除了对 __dict__ 的需求，从而减少了内存使用——当你创建大量类实例时，这一点尤其有益。由于内部结构简化，它还会使属性访问稍快。

虽然使用 __slots__ 会限制动态属性的赋值，但在内存受限的环境或性能敏感的应用中，这种取舍一般是值得的。对于轻量级类或数据容器，应用 __slots__ 是一种使代码更高效的简单方法。

代码对比与时间测量:

class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y
start = time.time()
points = [Point(i, i+1) for i in range(1000000)]
print(f"With slots: {time.time() - start:.4f}s")

时间测量结果:

使用 __slots__: 约
未使用 __slots__: 约

四、选择 math 模块函数而非运算符，确保速度与精度

对于数值计算，Python的 math 模块提供的函数是在C语言中实现的，这相比于纯Python编写的等效操作，具有更好的性能和精度。

例如，使用 math.sqrt() 一般比使用幂运算符（**）计算数字的次方更快、更准确。同样，像 math.sin()、math.exp() 和 math.log() 这样的函数都经过了高度优化，以确保速度和可靠性。

在紧密循环或大规模计算中，这些性能优势会变得尤为明显。通过在繁重的数值工作中依赖 math 模块，你可以实现更快的执行速度和更一致的结果，使其成为科学计算、模拟或任何数学密集型代码的首选。

代码对比与时间测量:

import math
numbers = list(range(10000000))
start = time.time()
roots = [math.sqrt(n) for n in numbers]
print(f"Math sqrt: {time.time() - start:.4f}s")


start = time.time()
roots = [n ** 0.5 for n in numbers]
print(f"Operator: {time.time() - start:.4f}s")

时间测量结果:

math.sqrt: 约
运算符: 约

五、预先分配已知大小的内存，避免动态调整开销

当你动态构建列表或数组时，Python会在它们增长时在后台调整其大小。虽然方便，但这种大小调整涉及内存分配和数据复制，会增加开销——尤其是在大型或性能关键的循环中。

如果你事先知道数据结构的最终大小，预先分配内存可以显著提升性能。通过用固定大小初始化列表或数组，你避免了重复的大小调整，并允许Python（或像NumPy这样的库）更有效地管理内存。

这项技术在数值计算、模拟和大规模数据处理中尤其有价值，即使是微小的优化也能累积起来。预分配有助于减少内存碎片，改善缓存局部性，并确保更可预测的性能。

代码对比与时间测量:

start = time.time()
result = [0] * 1000000
for i in range(1000000):
    result[i] = i
print(f"Pre-allocated: {time.time() - start:.4f}s")


start = time.time()
result = []
for i in range(1000000):
    result.append(i)
print(f"Dynamic: {time.time() - start:.4f}s")

时间测量结果:

预分配: 约
动态追加: 约

六、在“热循环”中避免异常处理，改用条件检查

虽然Python的异常处理对于管理意外行为来说是强劲且清晰的，但它不适合在性能关键的循环中高频率使用。引发和捕获异常涉及堆栈展开和上下文切换，这些都是相对昂贵的操作。

在**“热循环”（即重复运行或处理大量数据的代码段）中，使用异常来进行控制流会显著降低性能**。相反，应使用条件检查（如 if、in、is 等）来在错误发生之前进行预防。这种主动的方法速度快得多，并能带来更可预测的执行。

将异常保留给真正异常的情况，而不是作为预期的控制流程，将使代码更简洁、更快，尤其是在紧密循环或性能至关重大的实时应用中。

代码对比与时间测量:

numbers = list(range(10000000))
start = time.time()
total = 0
for i in numbers:
    if i % 2 != 0:
        total += i // 2
    else:
        total += i
print(f"Conditional: {time.time() - start:.4f}s")


start = time.time()
total = 0
for i in numbers:
    try:
        total += i / (i % 2)
    except ZeroDivisionError:
        total += i
print(f"Exception: {time.time() - start:.4f}s")

时间测量结果:

条件检查: 约
异常处理: 约

七、利用局部函数处理重复逻辑，加速名称解析

当一个特定的逻辑片段在函数内被重复使用时，将其定义为一个局部（嵌套）函数（也称为闭包），可以提高性能和代码组织性。局部函数受益于更快的名称解析，由于Python在局部作用域中查找变量的速度快于全局作用域。

除了性能提升，局部函数还有助于封装逻辑，使你的代码更简洁、更模块化。它们还可以捕获外部作用域的变量，让你无需传递额外的参数即可编写更灵活、可重用的内部逻辑。

这项技术在需要多次应用一样操作的函数中特别有用，例如循环、数据转换或递归过程。通过将频繁使用的逻辑保持在局部，可以减少运行时开销和认知负担。

代码对比与时间测量:

def outer():
    def add_pair(a, b):
        return a + b
    result = 0
    for i in range(10000000):
        result = add_pair(result, i)
    return result
start = time.time()
result = outer()
print(f"Local function: {time.time() - start:.4f}s")


def add_pair(a, b):
    return a + b
start = time.time()
result = 0
for i in range(10000000):
    result = add_pair(result, i)
print(f"Global function: {time.time() - start:.4f}s")

时间测量结果:

局部函数: 约
全局函数: 约

八、借助 itertools 模块处理组合操作，实现高性能迭代

当处理排列、组合、笛卡尔积或其它基于迭代器的任务时，Python的 itertools 模块提供了一套高度优化、C语言实现的工具，专为这些用例量身定制。

像 product()、permutations()、combinations() 和 combinations_with_replacement() 这样的函数会惰性地生成元素，这意味着它们不会将整个结果存储在计算机内存中。这允许你处理大型或无限序列，而无需承担手动实现所带来的性能或内存损失。

除了速度快，itertools 函数还具有可组合性和内存效率，使其成为复杂数据操作、算法开发和解决问题（如模拟、搜索算法或竞技编程中的任务）的理想选择。当性能和可扩展性至关重大时，itertools 是首选解决方案。

代码对比与时间测量:

from itertools import product
items = [1, 2, 3] * 10
start = time.time()
result = list(product(items, repeat=2))
print(f"Itertools: {time.time() - start:.4f}s")


start = time.time()
result = []
for x in items:
    for y in items:
        result.append((x, y))
print(f"Loops: {time.time() - start:.4f}s")

时间测量结果:

itertools: 约
循环: 约

九、使用 bisect 模块操作有序列表，享受二分查找效率

在处理有序列表时，使用线性搜索或手动插入逻辑可能会很低效，特别是随着列表的增长。Python的 bisect 模块提供了快速、高效的工具，通过二分查找来维护有序状态。

借助 bisect_left()、bisect_right() 和 insort() 等函数，你可以以 的时间复杂度执行插入和搜索操作，这与简单扫描的复杂度形成鲜明对比。这在维护排行榜、事件时间线或实现高效范围查询等场景中特别有用。

通过使用 bisect，你避免了每次更改后的重新排序，并在处理动态、有序数据时获得了显著的性能提升。它是一个轻量级而强劲的工具，为常见的列表操作带来了算法上的效率。

代码对比与时间测量:

import bisect
numbers = sorted(list(range(0, 1000000, 2)))
start = time.time()
bisect.insort(numbers, 75432)
print(f"Bisect: {time.time() - start:.4f}s")


start = time.time()
for i, num in enumerate(numbers):
    if num > 75432:
        numbers.insert(i, 75432)
        break
print(f"Loop: {time.time() - start:.4f}s")

时间测量结果:

bisect: 约
循环: 约

十、避免在循环中重复调用函数，实现结果缓存

在循环内部多次调用同一个函数（尤其是当该函数开销大或每次都产生一样结果时），会导致不必要的开销。即使是相对快速的函数，在大型循环中被重复调用时，其累积成本也会变得超级可观。

为了优化，应在循环外部计算结果一次，并将其存储在一个局部变量中。这样做可以减少函数调用开销，并提高运行时效率，尤其是在性能关键的代码段中。

这项技术简单但有效。它不仅能加速执行，还能通过表明该值在循环上下文中是常量来增强代码的清晰度。缓存函数结果是消除冗余计算并使代码更高效的最简单方法之一。

代码对比与时间测量:

def expensive_operation():
    time.sleep(0.001)
    return 42
start = time.time()
cached_value = expensive_operation()
result = 0
for i in range(1000):
    result += cached_value
print(f"Cached: {time.time() - start:.4f}s")


start = time.time()
result = 0
for i in range(1000):
    result += expensive_operation()
print(f"Repeated: {time.time() - start:.4f}s")