Python 内存优化技巧

当您的项目规划越来越大时，高效办理内存资源就成为必然要求。遗憾的是，Python，尤其是与 C 或 C 等低级言语比较，似乎内存功率不够高。现在是否应该更换编程言语？当然不是。事实上，从优异的模块和东西到先进的数据结构和算法，有很多办法能够显著优化 Python 程序的内存运用。

本文将重点介绍 Python 的内置机制，并介绍 7 种原始但有用的内存优化技巧。掌握这些技巧将大大提高你的 Python 编程能力。

1. 在类界说中运用 __slots__

Python 作为一种动态类型编程言语，在 OOP 方面有更大的灵活性。在运转时向 Python 类中增加额定的特点和办法就是一个很好的比如。

例如，下面的代码界说了一个名为 Author 的类。它开始有两个特点 name 和 age。但咱们能够在稍后轻松地增加一个额定的特点：

class Author:
    def __init__(self, name, age):
        self.name = name
        self.age = age
me = Author('Yang Zhou', 30)
me.job = 'Software Engineer'
print(me.job)
# Software Engineer

但是，任何硬币都有两面。这种灵活性会浪费更多内存。

由于 Python 中每个类的实例都会保护一个特别的字典 (__dict__)，用于存储实例变量。由于字典的底层是基于哈希表的完成，因而字典本身的内存功率很低，因而字典会消耗很多内存。

在大多数情况下，咱们不需求在运转时更改实例的变量或办法，并且在类界说之后，__dict__ 也不会被更改。因而，咱们最好不要保护 __dict__ 字典。

Python 为此供给了一个奇特的特点：__slots__。

它经过指定类的所有有用特点的称号，起到白名单的效果：

class Author:
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age
me = Author('Yang Zhou', 30)
me.job = 'Software Engineer'
print(me.job)
# AttributeError: 'Author' object has no attribute 'job'

就像上面的代码，咱们不能再在运转时增加作业特点了。由于 __slots__ 白名单只界说了 name 和 age 两个有用特点。

从理论上讲，由于特点是固定的，Python 不需求为它保护一个字典。它只需为 __slots__ 中界说的特点分配必要的内存空间即可。

让咱们写一个简略的比较程序来看看它是否真的能够这样作业：

import sys
class Author:
    def __init__(self, name, age):
        self.name = name
        self.age = age
class AuthorWithSlots:
    __slots__ = ['name', 'age']
    def __init__(self, name, age):
        self.name = name
        self.age = age
# Creating instances
me = Author('Yang', 30)
me_with_slots = AuthorWithSlots('Yang', 30)
# Comparing memory usage
memory_without_slots = sys.getsizeof(me)   sys.getsizeof(me.__dict__)
memory_with_slots = sys.getsizeof(me_with_slots)  # __slots__ classes don't have __dict__
print(memory_without_slots, memory_with_slots)
# 152 48
print(me.__dict__)
# {'name': 'Yang', 'age': 30}
print(me_with_slots.__dict__)
# AttributeError: 'AuthorWithSlots' object has no attribute '__dict__'

如上面的代码所示，由于运用了 __slots__，实例 me_with_slots 没有__dict__ 字典。与需求保存额定字典的 me 实例比较，它有用地节约了内存资源。

2. 运用生成器

生成器是 Python 中列表的懒版本。它们的作业方式类似于元素生成工厂：每逢调用 next() 办法时就生成一个项，而不是一次性计算所有项。因而，在处理大型数据集时，它们十分节约内存。

def number_generator():
    for i in range(100):
        yield i
numbers = number_generator()
print(numbers)
# <generator object number_generator at 0x104a57e40>
print(next(numbers))
# 0
print(next(numbers))
# 1

上面的代码展示了一个编写和运用生成器的基本示例。关键字 yield 是生成器界说的中心。运用它意味着只要在调用 next() 办法时，才会产生项目 i。

现在，让咱们比较一下生成器和列表，看看哪一个更节约内存：

import sys
numbers = []
for i in range(100):
    numbers.append(i)
def number_generator():
    for i in range(100):
        yield i
numbers_generator = number_generator()
print(sys.getsizeof(numbers_generator))
# 112
print(sys.getsizeof(numbers))
# 920

上述程序的成果证明，运用生成器能够大大节约内存运用量。

趁便提一下，假如咱们把 list 理解的方括号转换成小括号，它就会变成一个生成器表达式。这是在 Python 中界说生成器的一种更简略的办法：

import sys
numbers = [i for i in range(100)]
numbers_generator = (i for i in range(100))
print(sys.getsizeof(numbers_generator))
# 112
print(sys.getsizeof(numbers))
# 920

3. 利用内存映射文件支持大文件处理

内存映射文件 I/O，简称 mmap，是一种操作系统级优化。

维基百科：它完成了需求分页，由于文件内容不会立即从磁盘读取，开始底子不运用物理 RAM。从磁盘实际读取的操作是在访问特定位置后，以一种懒散的方式进行的。

简略地说，当运用 mmap 技能对文件进行内存映射时，它会直接在当前进程的虚拟内存空间中创立文件的映射，而不是将整个文件加载到内存中。映射而不是加载整个文件能够节约很多内存。

看起来很杂乱？幸运的是，Python 现已供给了运用这种技能的内置模块，因而咱们能够轻松利用它，而无需考虑操作系统级的完成。

例如，在 Python 中如何运用 mmap 进行文件处理：

import mmap
with open('test.txt', "r b") as f:
    # memory-map the file, size 0 means whole file
    with mmap.mmap(f.fileno(), 0) as mm:
        # read content via standard file methods
        print(mm.read())
        # read content via slice notation
        snippet = mm[0:10]
        print(snippet.decode('utf-8'))

如上所述，Python 使内存映射文件 I/O 技能的运用变得十分方便。咱们需求做的仅仅是应用 mmap.mmap() 办法，然后运用标准文件办法乃至切片符号来处理打开的目标。

4. 尽量少用全局变量

全局变量具有全局效果域，因而只要程序运转，全局变量就会一向保留在内存中。

因而，假如一个全局变量包括一个大型数据结构，它就会在整个程序生命周期中占用内存，从而或许导致内存运用功率低下。

咱们应该在 Python 代码中尽量减少全局变量的运用。

5. 利用逻辑操作符

这个技巧看似奇妙，但奇妙地运用它将极大地节约程序的内存运用量。

例如，下面是一个简略的代码片段，它依据两个函数回来的布尔值得到最终成果：

result_a = expensive_function_a()
result_b = expensive_function_b()
result = result_a if result_a else result_b

上述代码能够正常运转，但它实际上履行了两个内存不足的函数。

取得相同成果的更聪明的办法如下：

result = expensive_function1() or expensive_function2()

由于逻辑运算符遵循短路评估规则，假如 expensive_function1() 为 True，则不会履行上述代码中的 expensive_function2()。这将节约不必要的内存运用。

6. 谨慎挑选数据类型

资深的 Python 开发人员会谨慎而精确地挑选数据类型。由于在某些情况下，运用一种数据类型比运用另一种数据类型更节约内存。

元组比列表更节约内存

鉴于元组是不可变的（创立后不能更改），它答应 Python 在内存分配方面进行优化。但是，列表是可变的，因而需求额定的空间来包容潜在的修改。

import sys
my_tuple = (1, 2, 3, 4, 5)
my_list = [1, 2, 3, 4, 5]
print(sys.getsizeof(my_tuple))
# 80
print(sys.getsizeof(my_list)) 
# 120

如上面的代码段所示，即使包括相同的元素，元组 my_tuple 运用的内存也比 list 少。

因而，假如在创立后不需求更改数据，咱们应该首选元组而不是列表。

数组比 list 更节约内存

Python 中的数组要求元素具有相同的数据类型（例如，所有整数或所有浮点数），但列表能够存储不同类型的目标，这就不可避免地需求更多内存。

因而，假如列表的元素都是同一类型，运用数组会更节约内存：

import sys
import array
my_list = [i for i in range(1000)]
my_array = array.array('i', [i for i in range(1000)])
print(sys.getsizeof(my_list))  
# 8856
print(sys.getsizeof(my_array)) 
# 4064

优异的数据科学模块比内置数据类型更高效

Python 是数据科学的控制言语。有许多强壮的第三方模块和东西供给了更多的数据类型，如 NumPy 和 Pandas。

假如咱们只需求一个简略的一维数组，而不需求 NumPy 供给的广泛功用，那么 Python 的内置数组或许是一个不错的挑选。

但假如需求进行杂乱的矩阵操作，运用 NumPy 供给的数组或许是所有数据科学家的首选，也或许是最佳挑选。

7. 对相同字符串应用字符串互文技能

下面的代码会让很多开发人员感到困惑：

>>> a = 'Y'*4096
>>> b = 'Y'*4096
>>> a is b
True
>>> c = 'Y'*4097
>>> d = 'Y'*4097
>>> c is d
False

咱们知道，is 运算符用于检查两个变量是否指向内存中的同一个目标。它与 == 运算符不同，后者用于比较两个目标是否具有相同的值。

那么，为什么 a is b 得到的是 True，而 c is d 得到的却是 False 呢？

假如有几个小字符串的值相同，Python 就会隐式地对它们进行内联，并引用内存中的同一个目标。

界说小字符串的奇特数字是 4096。由于 c 和 d 的长度都是 4097，所以它们在内存中是两个目标，而不是一个。不再有隐式字符串互调。因而，当履行 c 是 d 时，咱们会得到一个 False。

字符串互调是一种优化内存运用的强壮技能。假如咱们想显式地进行字符串互调，sys.intern() 办法就很好用：

>>> import sys
>>> c = sys.intern('Y'*4097)
>>> d = sys.intern('Y'*4097)
>>> c is d
True

趁便说一下，除了字符串互调，Python 还将互调技巧应用于小整数。咱们还能够利用它来优化内存。