大多数时候，我们不需要优化Python中的内存使用情况。我们的程序太小而无法占用大量内存，或者我们正在将数据存储在程序外部的数据库中。无论如何，在某些情况下，我们必须在内存中保留过大的结构或大量的对象。因此，我希望举例说明可以减少程序内存使用量的做法。

议程

• 用__slots__限制类字段
• Generator惰性加载
• 用数组约束元素类型

用__slots__限制类字段

默认情况下，每当您在Python中创建对象时，即使在创建之后，您也能够将新字段添加到对象。

例如，假设我有一个名为Dog的类：

1. class Dog:  
2.     def __init__(self, name, age):  
3.     self.name = name  
4.         self.age = age 
5.     def main():  
6.     dog = Dog("James", 5)  
7.         dog.breed = "Pitbull"  
8.         print(dog.breed) 
9.  
10. main() 

尽管名称和年龄是我传递给构造函数的唯一字段，但是请注意，在创建dog之后，如何初始化一个名为繁殖的新字段。本质上，dog的字段存储在内部字典中，可通过.__ dict__访问，并且在初始化dog.breed时，将其值为“ Pitbull”的字段“ breed”添加到内部字典中。

1. def main(): 
2.     dog = Dog("James", 5) 
3.     print(dog.__dict__)  
4.     ''' 
5.     output: {'name': 'James', 'age': 5} 
6.     ''' 
7.     dog.breed = "Pitbull"
8.     print(dog.__dict__) 
9.     ''' 
10.     output: {'name': 'James', 'age': 5, 'breed': 'Pitbull'} 
11.     ''' 
12. main() 

尽管这提供了灵活性，但大多数时候我们不需要在实例化之外添加新字段。为了节省内存占用量，我们可以设置Dog的__slots__属性来预定义其字段。

1. class Dog: 
2.     __slots__ = ("name", "age") 
3.     def __init__(self, name, age): 
4.         self.name = name
5.         self.age = age 

使用__slots__可以防止创建内部字典，从而使我们可以更紧凑地存储实例字段。但是，现在，我们不再能够即时创建新字段。

1. def main(): 
2.     dog = Dog("James", 5) 
3.     dog.breed = "Pitbull"  
4.     ''' 
5.     output: AttributeError:'Dog' object has no attribute 'breed'
6.     ''' 
7.    
8. main() 

为了测试__slots__的内存使用情况，我创建了100,000个Dog和SlotDog对象。

1. class Dog: 
2.    
3.   def __init__(self, name, age): 
4.     self.name = name
5.     self.age = age 
6. class SlotDog: 
7.      
8.    __slots__=("name", "age") 
9.    def __init__(self, name, age): 
10.      self.name = name
11.      self.age = age 

然后，我使用memory_profiler分解了创建100,000个对象后内存使用量的增加情况。创建Dog对象后，内存使用量增加了16.5 MiB，而SlotDog对象则增加了5.8 MiB，这表明使用__slots__有了很大的改进。您可以在GitHub上查看创建代码(https://github.com/Ramko9999/Medium-Memory-Efficient-Python/blob/main/slots_perf.py)。

在必须实例化具有预定字段的大量对象的情况下，使用__slots__将是有益的。

用Genertor惰性加载

当使用大文件或集合时，可能无法加载整个文件或将集合维护在内存中。如果我们可以一次处理多个文件或集合中的一个元素，那就太好了。

进入生成器!

让我们考虑一个例子。说我需要获取前n个奇数进行处理。自然地，我们可以创建一个列表并附加前n个奇数。

1. def get_odds_list(n): 
2.     odds = [] 
3.     num = 1 
4.     for i in range(n): 
5.         odds.append(num) 
6.         num += 2 
7.     return odds 

但是，如果我们要处理前几百万的赔率，那么在内存中维护此列表将变得昂贵。更好的方法是在我们计算赔率时利用生成器迭代赔率，而不是计算和存储所有百万赔率。

这是上面的函数作为生成器的样子：

1. def get_odds_generator(n): 
2.     num = 1 
3.     for i in range(n): 
4.         yield num 
5.         num += 2 
6. odds = get_odds_generator(1000000) 

当我们初始化赔率时，尚未计算任何奇数。此刻的赔率只是一个迭代器，一个值序列。为了访问迭代器中的元素，我们必须在迭代器上调用next。顾名思义，next返回序列中的下一个值。

神奇之处在于yield关键字：它使函数成为生成器。本质上，当按赔率调用next时，生成器get_odds_generator将评估其代码，直到达到yield为止。然后，生成器将返回该值，并且其状态将冻结。然后，再次调用next时，生成器将从中断状态重新开始评估其代码。

1. def get_odds_generator(n): 
2.     num = 1 
3.     for i in range(n): 
4.         yield num 
5.         num += 2 
6.  
7. odds = get_odds_generator(1000000) 
8.  
9. first = next(odds) 
10. ''' 
11. first = 1 
12. Explanation: num is 1. We enter the for loop and immediately yield num 
13. ''' 
14.  
15. second = next(odds) 
16. ''' 
17. second = 3  
18. Explanation: num is 1. We add 2 to num, so its now 3.  
19. We go the next iteration of the loop and yield num 
20. ''' 
21.  
22. third = next(odds) 
23. ''' 
24. third = 5 
25. Explanation: num is 3. We add 2 to num, so its now 5.  
26. We go to the next iteration of the loop and yield num 
27. ''' 

我们还可以按照以下方式浏览生成器生成的值。

1. odds = get_odds_generator(1000000) 
2. for odd in odds: 
3.     pass //process the odd 

我们可以使用生成器来计算赔率。因此，我们不需要任何额外的内存来存储赔率。

使用生成器的一个警告是，我们将无法获取先前的元素或跳过元素的序列。如果您需要访问以前的元素，则最好直接使用列表。