MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python内存优化与性能提升技巧

2021-09-114.6k 阅读

Python内存管理基础

在深入探讨Python内存优化与性能提升技巧之前，我们先来了解一下Python内存管理的基础知识。

Python的内存管理机制

Python拥有一套自动的内存管理系统，它负责分配和释放内存。这其中最核心的部分是垃圾回收（Garbage Collection，GC）机制。Python的垃圾回收主要基于引用计数（Reference Counting），每个对象都有一个引用计数，当对象的引用计数变为0时，该对象所占用的内存就会被回收。

例如，我们来看下面这段简单的代码：

a = [1, 2, 3]  # 创建一个列表对象，a 引用该对象
b = a         # b 也引用该对象，此时列表对象的引用计数为2
a = None      # a 不再引用该对象，列表对象的引用计数减为1
b = None      # b 也不再引用该对象，列表对象的引用计数变为0，内存被回收

然而，引用计数并非完美无缺。它无法解决循环引用的问题，即两个或多个对象相互引用，导致它们的引用计数永远不会变为0。为了解决这个问题，Python还引入了标记 - 清除（Mark - Sweep）和分代回收（Generational Collection）机制。

标记 - 清除机制会定期扫描堆内存，标记所有可达对象（即从根对象可以访问到的对象），然后清除所有未标记的对象，这些未标记的对象就是不再被使用的对象。

分代回收机制基于这样一个假设：新创建的对象很可能很快就不再被使用，而存活时间较长的对象则更有可能继续存活。Python将对象分为不同的代，新创建的对象放在年轻代，随着对象存活时间的增加，它们会被移动到更老的代。垃圾回收器会更频繁地扫描年轻代，因为这里的对象更有可能是垃圾。

内存分配

在Python中，当我们创建一个新对象时，内存会从堆（heap）中分配。对于一些小对象（如整数、短字符串等），Python会使用对象池（Object Pooling）技术来提高内存分配效率。例如，Python会预先分配一定数量的小整数对象，并将它们保存在一个池中，当我们创建一个小整数（通常在 -5 到 256 之间）时，实际上是从池中获取一个已有的对象，而不是重新分配内存。

a = 100
b = 100
print(a is b)  # 输出 True，因为 a 和 b 指向同一个对象

对于大对象（如大型列表、字典等），则会从堆中分配新的内存空间。此外，Python还提供了一些底层的内存分配接口，如 sys._getframe().f_code.co_code 可以获取当前函数的字节码，这在一些高级的内存管理场景中可能会用到，但使用这些接口需要非常小心，因为它们可能会破坏Python的内存管理机制。

内存优化技巧

了解了Python内存管理的基础知识后，我们现在可以探讨一些内存优化的技巧。

合理使用数据结构

选择合适的数据结构对于内存优化至关重要。

列表（List）与生成器（Generator）

列表是Python中常用的数据结构，它会一次性将所有元素加载到内存中。如果数据量较大，这可能会导致内存占用过高。相比之下，生成器是一种惰性求值的序列，它不会一次性生成所有元素，而是在需要时逐个生成。

例如，假设我们要生成一个包含1000万个整数的序列，如果使用列表：

import sys
nums_list = list(range(10000000))
print(sys.getsizeof(nums_list))  # 输出列表占用的内存大小

而使用生成器：

nums_generator = (i for i in range(10000000))
print(sys.getsizeof(nums_generator))  # 输出生成器占用的内存大小，通常远小于列表

可以看到，生成器在内存占用上具有明显优势，尤其是在处理大数据集时。

字典（Dictionary）与集合（Set）

字典和集合在Python中都基于哈希表实现。字典用于存储键值对，而集合则用于存储唯一元素。在内存使用方面，如果只需要存储唯一的元素，使用集合会比字典更节省内存，因为集合不需要存储值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_set = {'a', 'b', 'c'}
print(sys.getsizeof(my_dict))
print(sys.getsizeof(my_set))

通常情况下，集合的内存占用会小于字典，因为它不需要额外存储值的空间。

数组（Array）与列表

Python的 array 模块提供了一种比列表更紧凑的数据结构，适用于存储同类型的数据。例如，如果我们要存储大量的整数，使用 array 会比列表节省内存。

import array
nums_array = array.array('i', range(1000000))  # 'i' 表示有符号整数
nums_list = list(range(1000000))
print(sys.getsizeof(nums_array))
print(sys.getsizeof(nums_list))

由于 array 只存储数据，没有像列表那样存储额外的元数据（如对象类型等），所以在存储大量同类型数据时，内存占用更低。

避免不必要的对象创建

在Python中，频繁创建对象会增加内存分配和垃圾回收的开销。

重用对象

例如，在循环中创建新的字符串对象是一种常见的内存浪费行为。如果需要在循环中拼接字符串，应该使用 str.join() 方法而不是 + 运算符。

# 不推荐的方式
s = ''
for i in range(1000):
    s = s + str(i)
# 推荐的方式
parts = []
for i in range(1000):
    parts.append(str(i))
s = ''.join(parts)

在第一种方式中，每次使用 + 运算符都会创建一个新的字符串对象，而 str.join() 方法只在最后创建一个字符串对象，大大减少了对象创建的次数。

使用局部变量

局部变量的作用域仅限于函数内部，当函数返回时，局部变量所占用的内存会被释放。相比之下，全局变量的生命周期较长，会一直占用内存直到程序结束。因此，尽量在函数内部使用局部变量，避免不必要的全局变量。

# 不推荐
global_var = []
def my_function():
    global global_var
    global_var.append(1)
# 推荐
def my_function():
    local_var = []
    local_var.append(1)
    return local_var

在这个例子中，使用局部变量 local_var 可以在函数结束后及时释放内存，而全局变量 global_var 会一直占用内存。

优化循环

循环是程序中常用的结构，但不当的循环实现可能会导致性能问题和内存浪费。

减少循环内的计算

将循环内的不变计算移到循环外部，可以减少每次循环的计算量。

# 不推荐
for i in range(1000):
    result = i * math.sqrt(25)
# 推荐
sqrt_25 = math.sqrt(25)
for i in range(1000):
    result = i * sqrt_25

在第一个例子中，每次循环都要计算 math.sqrt(25)，而在第二个例子中，将该计算移到循环外，只计算一次。

使用内置函数和迭代器

Python的内置函数和迭代器通常经过优化，性能较好。例如，使用 map() 和 filter() 函数代替显式的循环。

nums = [1, 2, 3, 4, 5]
# 不推荐
squared_nums = []
for num in nums:
    squared_nums.append(num ** 2)
# 推荐
squared_nums = list(map(lambda x: x ** 2, nums))

map() 函数会对可迭代对象中的每个元素应用指定的函数，并且它返回的是一个迭代器，在内存使用上更高效。类似地，filter() 函数用于过滤可迭代对象中的元素，也比显式循环更高效。

垃圾回收优化

虽然Python的垃圾回收机制是自动的，但我们可以采取一些措施来优化它的性能。

手动触发垃圾回收

在某些情况下，我们可能希望手动触发垃圾回收，以尽快释放不再使用的内存。可以使用 gc 模块来实现这一点。

import gc
# 手动触发垃圾回收
gc.collect()

然而，手动触发垃圾回收应该谨慎使用，因为垃圾回收本身也有一定的开销，如果频繁触发，可能会降低程序的整体性能。

调整垃圾回收阈值

垃圾回收的频率和阈值可以通过 gc 模块进行调整。例如，可以通过 gc.set_threshold() 函数来设置分代回收的阈值。

import gc
# 获取当前的垃圾回收阈值
threshold0, threshold1, threshold2 = gc.get_threshold()
print(f"Threshold0: {threshold0}, Threshold1: {threshold1}, Threshold2: {threshold2}")
# 设置新的阈值
gc.set_threshold(700, 10, 10)

通过调整这些阈值，可以控制垃圾回收的频率，找到一个适合程序性能的平衡点。如果阈值设置过低，垃圾回收会过于频繁，增加开销；如果阈值设置过高，垃圾回收可能不及时，导致内存占用过高。

性能提升技巧

除了内存优化，提升Python程序的性能也是非常重要的。

使用JIT编译器

即时编译（Just - In - Time，JIT）编译器可以在运行时将Python代码编译为机器码，从而提高程序的执行速度。

Numba

Numba是一个用于Python的JIT编译器，它特别适用于数值计算密集型的代码。例如，假设我们有一个计算斐波那契数列的函数：

import numba

@numba.jit(nopython=True)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

通过使用 @numba.jit(nopython=True) 装饰器，Numba会将这个函数编译为机器码，大大提高其执行效率。在 nopython 模式下，Numba会避免使用Python的解释器，直接生成高效的机器码，从而获得更好的性能提升。

PyPy

PyPy是一个Python的替代实现，它内置了JIT编译器。使用PyPy运行Python程序通常可以获得显著的性能提升，尤其是对于那些包含大量循环和数值计算的程序。要使用PyPy，只需将Python代码在PyPy环境中运行即可，无需对代码进行太多修改。例如，将上述斐波那契数列计算函数保存为 fib.py 文件，然后在PyPy环境中运行：

pypy fib.py

PyPy会自动对代码进行优化，通过JIT编译将热点代码转换为机器码，提高执行速度。

多线程与多进程

Python提供了多线程和多进程模块，用于利用多核CPU的优势，提高程序的并发性能。

多线程（threading 模块）

多线程适用于I/O密集型任务，如网络请求、文件读写等。在Python中，由于全局解释器锁（Global Interpreter Lock，GIL）的存在，多线程在CPU密集型任务中并不能充分利用多核CPU的优势。然而，对于I/O密集型任务，多线程可以在一个线程等待I/O操作完成时，切换到其他线程执行，从而提高整体效率。

import threading
import time

def io_bound_task():
    time.sleep(2)  # 模拟I/O操作，如文件读取或网络请求
    print('Task completed')

threads = []
for _ in range(5):
    thread = threading.Thread(target=io_bound_task)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

在这个例子中，我们创建了5个线程来执行I/O密集型任务，通过多线程可以在一定程度上提高程序的执行效率。

多进程（multiprocessing 模块）

多进程适用于CPU密集型任务，因为每个进程都有自己独立的Python解释器和内存空间，不存在GIL的限制。例如，假设我们有一个CPU密集型的计算任务：

import multiprocessing
import time

def cpu_bound_task(n):
    result = 0
    for i in range(n):
        result += i
    return result

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = pool.map(cpu_bound_task, [10000000] * 4)
    pool.close()
    pool.join()
    print(results)

在这个例子中，我们使用 multiprocessing.Pool 创建了一个进程池，包含4个进程，然后使用 map() 方法并行执行CPU密集型任务，充分利用多核CPU的性能。

优化I/O操作

I/O操作（如文件读写、网络请求等）通常比较耗时，优化I/O操作可以显著提升程序性能。

文件读写

在进行文件读写时，可以使用缓冲区来减少实际的I/O次数。Python的文件对象默认有一定的缓冲区大小，但在某些情况下，我们可以手动调整缓冲区大小以获得更好的性能。

# 以二进制模式打开文件，并设置缓冲区大小为64KB
with open('large_file.bin', 'wb', buffering=65536) as f:
    data = b'0' * 1024 * 1024  # 1MB的数据
    for _ in range(100):
        f.write(data)

此外，使用 with 语句可以确保文件在使用完毕后正确关闭，避免资源泄漏。

网络请求

在进行网络请求时，可以使用异步I/O库（如 aiohttp）来提高效率。异步I/O允许在等待网络响应时执行其他任务，而不是阻塞线程。

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, 'http://example.com') for _ in range(10)]
        results = await asyncio.gather(*tasks)
        print(results)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

在这个例子中，我们使用 aiohttp 和 asyncio 实现了异步网络请求，通过 asyncio.gather() 可以并发执行多个请求，提高整体的网络请求效率。

使用高效的库

Python有许多高效的第三方库，这些库通常经过优化，可以显著提升程序的性能。

Numpy

Numpy是Python中用于数值计算的核心库，它提供了高效的多维数组对象和各种数学运算函数。与Python原生的列表相比，Numpy数组在内存占用和计算速度上都有很大优势。

import numpy as np

# 创建Numpy数组
nums_np = np.array([1, 2, 3, 4, 5])
# 进行数组运算
squared_nums_np = nums_np ** 2
print(squared_nums_np)

Numpy的底层使用C语言实现，因此在执行数值计算时，速度比使用Python原生列表和循环要快得多。

Pandas

Pandas是用于数据处理和分析的库，它建立在Numpy之上，提供了高效的数据结构（如 DataFrame 和 Series）和数据处理函数。对于数据处理任务，Pandas可以大大提高效率。

import pandas as pd

data = {'col1': [1, 2, 3, 4, 5], 'col2': [6, 7, 8, 9, 10]}
df = pd.DataFrame(data)
result = df['col1'] + df['col2']
print(result)

Pandas的 DataFrame 数据结构可以方便地进行数据的读取、清洗、分析等操作，并且其内部实现经过优化，性能较高。

代码性能分析与优化流程

在实际开发中，我们需要一种系统的方法来分析和优化代码的性能。

使用性能分析工具

cProfile

cProfile 是Python内置的性能分析工具，它可以帮助我们确定代码中哪些部分花费的时间最多。例如，假设我们有一个包含多个函数的Python脚本：

import cProfile

def function1():
    result = 0
    for i in range(1000000):
        result += i
    return result

def function2():
    result = 1
    for i in range(1000):
        result *= i
    return result

def main():
    function1()
    function2()

cProfile.run('main()')

运行上述代码后，cProfile 会输出每个函数的调用次数、执行时间等详细信息，我们可以根据这些信息找出性能瓶颈，如 function1 中的循环可能是导致性能问题的原因。

line_profiler

line_profiler 是一个可以逐行分析代码性能的工具。要使用它，首先需要安装 line_profiler 库，然后使用 @profile 装饰器标记需要分析的函数。

from line_profiler import LineProfiler

def function_to_profile():
    result = 0
    for i in range(1000000):
        result += i
    return result

profile = LineProfiler()
profile.add_function(function_to_profile)
profile.run('function_to_profile()')
profile.print_stats()

line_profiler 会输出每个代码行的执行次数和花费的时间，帮助我们更精确地定位性能问题，例如可以看到在循环中具体哪一行代码花费的时间最多。

优化流程

  1. 性能分析：使用 cProfile 或 line_profiler 等工具分析代码，找出性能瓶颈。
  2. 针对性优化：根据性能分析结果，应用前面提到的内存优化和性能提升技巧，如优化数据结构、减少对象创建、使用JIT编译器等。
  3. 再次分析：对优化后的代码再次进行性能分析，验证优化效果。如果性能没有达到预期，可以重复上述步骤，进一步优化。

例如，通过 cProfile 分析发现某个函数中的循环性能较差，我们可以考虑将循环内的不变计算移到循环外，或者使用更高效的数据结构。优化后再次使用 cProfile 分析，如果性能得到提升，则说明优化有效；如果没有提升，则需要进一步寻找其他可能的优化点。

通过遵循这样的优化流程，结合各种内存优化和性能提升技巧，我们可以开发出高效、低内存占用的Python程序。在实际应用中，根据具体的业务场景和需求，灵活选择合适的优化方法是关键。同时，也要注意优化的成本和收益，避免过度优化导致代码复杂度增加而影响维护性。