当前位置：首页 > 文章列表 > 文章 > python教程 > 强大的 Python 性能优化技术，可实现更快的代码

强大的 Python 性能优化技术，可实现更快的代码

来源：dev.to 2024-12-21 08:36:42 0浏览收藏

有志者，事竟成！如果你在学习文章，那么本文《强大的 Python 性能优化技术，可实现更快的代码》，就很适合你！文章讲解的知识点主要包括，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

作为一名 python 开发人员，我了解到优化代码对于创建高性能应用程序至关重要。在本文中，我将分享我用来增强 python 代码性能的七种强大技术，重点介绍提高执行速度和内存效率的实用方法。

生成器和迭代器

优化 python 代码最有效的方法之一是使用生成器和迭代器。这些工具在处理大型数据集时特别有用，因为它们允许我们处理数据，而无需立即将所有内容加载到内存中。

当我需要处理太大而无法轻松容纳在内存中的序列时，我经常使用生成器。这是生成素数的生成器函数的示例：

def prime_generator():
    yield 2
    primes = [2]
    candidate = 3
    while true:
        if all(candidate % prime != 0 for prime in primes):
            primes.append(candidate)
            yield candidate
        candidate += 2

这个生成器允许我处理无限的素数序列，而无需将它们全部存储在内存中。我可以这样使用它：

primes = prime_generator()
for _ in range(10):
    print(next(primes))

列表推导式和生成器表达式

列表推导式和生成器表达式是传统循环的简洁且通常更快的替代方案。它们对于创建新列表或迭代序列特别有用。

这是一个对偶数进行平方的列表理解的示例：

numbers = range(10)
squared_evens = [x**2 for x in numbers if x % 2 == 0]

对于较大的序列，我更喜欢生成器表达式以节省内存：

numbers = range(1000000)
squared_evens = (x**2 for x in numbers if x % 2 == 0)

高性能容器数据类型

python 中的集合模块提供了多种高性能容器数据类型，可以显着提高代码效率。

当我需要从列表两端快速追加和弹出时，我经常使用 deque（双端队列）：

from collections import deque

queue = deque(['a', 'b', 'c'])
queue.append('d')
queue.appendleft('e')

计数器是另一种用于计算可哈希对象的有用数据类型：

from collections import counter

word_counts = counter(['apple', 'banana', 'apple', 'cherry'])

用于快速查找的集合和字典

集合和字典在内部使用哈希表，这使得它们的查找和成员资格测试速度非常快。每当我需要检查集合中是否存在某个项目或需要从列表中删除重复项时，我都会使用它们。

这是使用集合进行快速成员资格测试的示例：

numbers = set(range(1000000))
print(500000 in numbers)  # this is much faster than using a list

使用 numba 进行即时编译

对于数值计算，numba 可以通过即时编译显着提高速度。以下是使用 numba 加速计算曼德尔布罗特集的函数的示例：

from numba import jit
import numpy as np

@jit(nopython=true)
def mandelbrot(h, w, maxit=20):
    y, x = np.ogrid[-1.4:1.4:h*1j, -2:0.8:w*1j]
    c = x + y*1j
    z = c
    divtime = maxit + np.zeros(z.shape, dtype=int)

    for i in range(maxit):
        z = z**2 + c
        diverge = z*np.conj(z) > 2**2
        div_now = diverge & (divtime == maxit)
        divtime[div_now] = i
        z[diverge] = 2

    return divtime

此函数比纯 python 等效函数快 100 倍。

c-speed 的 cython

当我需要更快的速度时，我会转向 cython。 cython 允许我将 python 代码编译为 c，从而显着提高性能。这是 cython 函数的简单示例：

def factorial(int n):
    cdef int i
    cdef int result = 1
    for i in range(2, n + 1):
        result *= i
    return result

这个 cython 函数可以比纯 python 实现快几倍。

分析和优化

在优化之前，确定瓶颈在哪里至关重要。我使用 cprofile 进行计时，使用 memory_profiler 进行内存使用分析。

这是我如何使用 cprofile：

import cprofile

def my_function():
    # some code here

cprofile.run('my_function()')

内存分析：

from memory_profiler import profile

@profile
def my_function():
    # some code here

my_function()

这些工具帮助我将优化工作集中在能产生最大影响的地方。

使用 functools.lru_cache 进行记忆

记忆化是我用来缓存昂贵函数调用结果的一种技术。 functools.lru_cache 装饰器使这变得简单：

from functools import lru_cache

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

这可以通过避免冗余计算来显着加快递归函数的速度。

使用 itertools 进行高效迭代

itertools 模块提供了一系列快速、内存高效的工具来创建迭代器。我经常将它们用于组合序列或生成排列等任务。

这是使用 itertools.combinations 的示例：

from itertools import combinations

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

编写高性能 python 代码的最佳实践

多年来，我开发了几种编写高效 python 代码的最佳实践：

优化循环：我尝试将尽可能多的代码移到循环之外。对于嵌套循环，我确保内部循环尽可能快。
减少函数调用开销：对于经常调用的非常小的函数，我考虑使用内联函数或 lambda 表达式。
使用适当的数据结构：我为任务选择正确的数据结构。例如，我使用集合进行快速成员资格测试，使用字典进行快速键值查找。
最小化对象创建：创建新对象可能会很昂贵，尤其是在循环内。我尝试尽可能重用对象。
使用内置函数和库：python 的内置函数和标准库通常经过优化并且比自定义实现更快。
避免全局变量：访问全局变量比访问局部变量慢。
使用 'in' 进行成员资格测试：对于列表、元组和集合，使用 'in' 比循环更快。

这是一个包含其中几种实践的示例：

from collections import defaultdict

def process_data(data):
    result = defaultdict(list)
    for item in data:
        key = item['category']
        value = item['value']
        if value > 0:
            result[key].append(value)
    return {k: sum(v) for k, v in result.items()}

此函数使用 defaultdict 来避免显式检查键是否存在，在单个循环中处理数据，并使用字典理解进行最终计算。

总之，优化 python 代码是一项需要实践和经验的技能。通过应用这些技术并始终衡量优化的影响，您可以编写出不仅优雅而且高性能的 python 代码。请记住，过早的优化是万恶之源，因此请务必首先分析您的代码，以确定真正需要优化的地方。