Python高级技巧:用一行代码减少一半内存占用

开发 后端
在这个项目中,我们必须要存储和处理一个相当大的动态列表。测试人员在测试过程中,抱怨内存不足。下面介绍一个简单的方法,通过添加一行代码来解决这个问题。

 

我想与大家分享一些我和我的团队在一个项目中经历的一些问题。在这个项目中,我们必须要存储和处理一个相当大的动态列表。测试人员在测试过程中,抱怨内存不足。下面介绍一个简单的方法,通过添加一行代码来解决这个问题。

图片的结果

下面我来解释一下,它是如何运行的。

首先,我们考虑一个简单的 "learning" 例子,创建一个 Dataltem  类,该类是一个人的个人信息,例如姓名,年龄,地址等。 

  1. class DataItem(object):  
  2.    def __init__(self, name, age, address):  
  3.        self.name = name  
  4.        self.age = age  
  5.        self.address = address 

初学者的问题:如何知道一个以上这样的对象占用多少内存?

首先,让我们试着解决一下: 

  1. d1 = DataItem("Alex", 42, "-")  
  2. print ("sys.getsizeof(d1):", sys.getsizeof(d1))

我们得到的答案是 56bytes,这似乎占用了很少的内存,相当满意喽。那么,我们在尝试另一个包含更多数据的对象例子: 

  1. d2 = DataItem("Boris", 24, "In the middle of nowhere")  
  2. print ("sys.getsizeof(d2):", sys.getsizeof(d2)) 

答案仍然是 56bytes,此刻,似乎我们意识到哪里有些不对?并不是所有的事情都第一眼所见那样。

  •  直觉不会让我们失望,一切都不是那么简单。Python 是一种具有动态类型的非常灵活的语言,对于它的工作,它存储了大量的附加数据。它们本身占据了很多。

例如,sys.getsizeof("") 返回 33bytes,是的一个多达 33 个字节的空行!并且 sys.getsizeof(1) 返回 24bytes,一个整个数字占用 24 个 bytes (我想咨询 C 语言程序员,远离屏幕,不想在进一步阅读,以免对美观失去信心)。对于更复杂的元素,如字典,sys.getsizeof(.()) 返回 272 字节,这是针对空字典的,我不会再继续了,我希望原理是明确的,并且 RAM 的制造商需要出售他们的芯片。

但是,我们回到我们的 DataItem 类和最初的初学者的疑惑。

这个类,占多少内存?

首先,我们一小写的形式将这个类的完整内容输出: 

  1. def dump(obj):  
  2.  for attr in dir(obj):  
  3.    print("  obj.%s = %r" % (attr, getattr(obj, attr))) 

这个函数将显示隐藏的“幕后”使所有 Python 函数(类型、继承和其他内容)都能够正常工作的内容。

结果令人印象深刻:

这一切内容占用多少内存?

下边有一个函数可以通过递归的方式,调用 getsizeof 函数,计算对象实际数据量。 

  1. def get_size(obj, seen=None):  
  2.    # From   
  3.    # Recursively finds size of objects  
  4.    size = sys.getsizeof(obj)  
  5.    if seen is None:  
  6.        seen = set()  
  7.    obj_id = id(obj)  
  8.    if obj_id in seen:  
  9.        return 0  
  10. # Important mark as seen *before* entering recursion to gracefully handle  
  11.    # self-referential objects  
  12.    seen.add(obj_id)  
  13.    if isinstance(obj, dict):  
  14.      size += sum([get_size(v, seen) for v in obj.values()])  
  15.      size += sum([get_size(k, seen) for k in obj.keys()])  
  16.    elif hasattr(obj, '__dict__'):  
  17.      size += get_size(obj.__dict__, seen)  
  18.    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):  
  19.      size += sum([get_size(i, seen) for i in obj])  
  20.    return size 

让我们试一试: 

  1. d1 = DataItem("Alex", 42, "-")  
  2. print ("get_size(d1):", get_size(d1))  
  3. d2 = DataItem("Boris", 24, "In the middle of nowhere")  
  4. print ("get_size(d2):", get_size(d2)) 

我们获得的答案分别为 460bytes 和 484bytes,这结果似乎是真实的。

使用这个函数,你可以进行一系列的实验。例如,我想知道如果 DataItem 结构放在列表中,数据将占用多少空间。get_size ([d1]) 函数返回 532bytes ,显然,这与上面说的 460+ 的开销相同。但是 get_size ([d1, d2]) 返回 863bytes ,小于以上的 460 + 484。get_size ([d1, d2, d1]) 的结果更有趣——我们得到了 871 字节,只是稍微多一点,也就是说 Python 足够聪明,不会再次为同一个对象分配内存。

现在,我们来看一看问题的第二部分。

是否存在减少内存开销的可能呢?

是的,可以的。Python 是一个解释器,我们可以在任何时候扩展我们的类,例如,添加一个新的字段: 

  1. d1 = DataItem("Alex", 42, "-")  
  2. print ("get_size(d1):", get_size(d1))  
  3. d1.weight = 66  
  4. print ("get_size(d1):", get_size(d1)) 

非常好,但是如果我们不需要这个功能呢?我们能强制解释器来指定类的列表对象使用 __slots__ 命令: 

  1. class DataItem(object):  
  2.    __slots__ = ['name', 'age', 'address'] 
  3.    def __init__(self, name, age, address):  
  4.        self.name = name 
  5.        self.age = age  
  6.        self.address = address 

更多信息可以在文档 (RTFM) 中找到,其中写到 “__ dict__和__weakref__”。使用 __dict__ 节省的空间非常大”。

我们确认:是的,确实很重要,get_size (d1) 返回 …64 字节,而不是 460 字节,即少 7 倍。另外,创建对象的速度要快 20% (请参阅本文的第一个屏幕截图)。

唉,真正使用如此大的内存增益并不是因为其他开销。通过简单地添加元素,创建一个 100,000 的数组,并查看内存消耗: 

  1. data = []  
  2. for p in range(100000):  
  3.    data.append(DataItem("Alex", 42, "middle of nowhere"))  
  4. snapshot = tracemalloc.take_snapshot()  
  5. top_stats = snapshot.statistics('lineno')  
  6. total = sum(stat.size for stat in top_stats)  
  7. print("Total allocated size: %.1f MB" % (total / (1024*1024))) 

我们不使用 __slots__ 占用内存 16.8MB,使用时占用 6.9MB。这个操作当然不是最好的,但是确实代码改变的最小的。(Not 7 times of course, but it’s not bad at all, considering that the code change was minimal.)

现在的缺点。激活 __slots__ 禁止所有元素的创建,包括 __dict__ ,这意味着,例如,一下代码将结构转换成 json 将不运行: 

  1. def toJSON(self):  
  2.        return json.dumps(self.__dict__) 

这个问题很容易修复,它是足以产生 dict 编程方式,通过所有元素的循环: 

  1. def toJSON(self):  
  2.        data = dict()  
  3.        for var in self.__slots__:  
  4.            data[var] = getattr(self, var)  
  5.        return json.dumps(data) 

也不可能动态给这个类添加新类变量,但是在这个例子中,这并不是必需的。

今天的最后一个测试。有趣的是整个程序需要多少内存。添加一个无限循环的程序,以便它不结束,看看 Windows 任务管理器中的内存消耗。

没有 __slots__:

6.9Mb 变成 27Mb … 好家伙, 毕竟, 我们节省了内存, 27Mb 代替 70 ,对于增加一行代码来说并不是一个坏的例子

注意:TraceMelc 调试库使用了许多附加内存。显然,她为每个创建的对象添加了额外的元素。如果关闭它,总的内存消耗将少得多,截屏显示两个选项:

如果你想节省更多的内存呢?

这可以使用 numpy 库,它允许您以 C 样式创建结构,但是在我的例子中,它需要对代码进行更深入的细化,并且第一种方法就足够了。

奇怪的是在 Habré 从来没有详细分析使用 __slots__, 我希望本文将填补这一空缺。

结论

这篇文章似乎是一个 anti-Python 广告,但并不是。Python 非常可靠(为了“降低” Python 程序,您必须非常努力),它是一种易于阅读和方便编写代码的语言。这些优点在很多情况下都大于缺点,但是如果您需要最大的性能和效率,您可以使用像 numpy 这样的库,它是用 C++ 编写的,它可以很快和高效地与数据一起工作。 

 

责任编辑:庞桂玉 来源: 马哥Linux运维
相关推荐

2011-08-17 10:53:16

Firefox 7

2022-09-28 10:12:50

Python代码可视化

2009-04-30 09:01:25

微软操作系统Windows 7

2016-12-02 08:53:18

Python一行代码

2022-02-24 10:40:14

Python代码

2022-04-09 09:11:33

Python

2015-07-27 10:24:01

苹果中国

2020-12-04 10:11:26

Unsafejava并发包

2013-02-25 10:11:35

4GLTE商用网络

2017-04-13 19:20:18

Python代码并行任务

2021-11-02 16:25:41

Python代码技巧

2020-08-19 10:30:25

代码Python多线程

2019-09-18 15:33:51

代码开发工具

2024-07-08 08:00:00

2023-03-02 08:35:38

内存算法设计

2023-03-07 09:40:33

内存死锁操作系统

2020-08-12 14:54:00

Python代码开发

2020-09-28 12:34:38

Python代码开发

2024-04-15 03:00:00

python代码开发

2014-02-12 13:43:50

代码并行任务
点赞
收藏

51CTO技术栈公众号