Python是一种很棒的编程语言。 它也以相当慢而闻名，主要是由于其巨大的灵活性和动态功能。 对于许多应用程序和领域，由于它们的要求和各种优化技术，这不是问题。 鲜为人知的是，Python对象图（列表和元组的嵌套字典以及原始类型）占用大量内存。 由于它对缓存，虚拟内存，与其他程序的多租户的影响，并且通常会更快耗尽可用内存，这是一种稀缺且昂贵的资源，因此这可能是一个更为严格的限制因素。

事实证明，弄清楚实际消耗了多少内存并不是一件容易的事。 在本文中，我将带您逐步了解Python对象的内存管理的复杂性，并展示如何准确地测量消耗的内存。

在本文中，我仅关注CPython — Python编程语言的主要实现。 这里的实验和结论不适用于其他Python实现，例如IronPython，Jython和PyPy。

另外，我还在64位Python 2.7上运行了这些数字。 在Python 3中，数字有时会稍有不同（尤其是对于始终为Unicode的字符串），但是概念是相同的。

动手探索Python内存使用情况

首先，让我们进行一些探索，并获得对Python对象实际内存使用情况的具体了解。

sys.getsizeof（）内置函数

标准库的sys模块提供getsizeof（）函数。 该函数接受一个对象（和可选的默认值），调用该对象的sizeof （）方法并返回结果，因此您也可以使对象可检查。

测量Python对象的内存

让我们从一些数字类型开始：

import syssys.getsizeof(5)
24

有趣。 整数需要24个字节。

sys.getsizeof(5.3)
24

嗯……一个浮点数也要占用24个字节。

from decimal import Decimal
sys.getsizeof(Decimal(5.3))
80

哇。 80个字节！ 这确实使您考虑要将大量实数表示为浮点数还是小数。

让我们继续进行字符串和集合：

sys.getsizeof('')
37
sys.getsizeof('1')
38
sys.getsizeof('1234')
41sys.getsizeof(u'')
50
sys.getsizeof(u'1')
52
sys.getsizeof(u'1234')
58

好。 一个空字符串占37个字节，每个附加字符增加另一个字节。 这说明了保持多个短字符串的折衷，在这种情况下，您将为每个字符串支付37个字节的开销，而在单个长字符串中，您只需支付一次开销。

Unicode字符串的行为类似，只是开销为50个字节，每个附加字符加2个字节。 如果使用返回Unicode字符串的库，那是要考虑的事情，但是您的文本可以表示为简单的字符串。

顺便说一下，在Python 3中，字符串始终是Unicode，开销是49个字节（它们在一个地方保存了一个字节）。 bytes对象的开销仅为33个字节。 如果您有一个程序可以处理内存中的许多短字符串并且您在乎性能，那么请考虑使用Python 3。

sys.getsizeof([])
72
sys.getsizeof([1])
88
sys.getsizeof([1, 2, 3, 4])
104
sys.getsizeof(['a long longlong string'])

这是怎么回事？ 空列表占用72个字节，但每个附加的int仅添加8个字节，其中int的大小为24个字节。 包含长字符串的列表仅占用80个字节。

答案很简单。 该列表不包含int对象本身。 它仅包含指向实际int对象的8字节（在CPython的64位版本上）。 这意味着getsizeof（）函数不会返回列表及其包含的所有对象的实际内存，而是仅返回列表的内存及其对象的指针。 在下一节中，我将介绍可解决此问题的deep_getsizeof（）函数。

sys.getsizeof(())
56
sys.getsizeof((1,))
64
sys.getsizeof((1, 2, 3, 4))
88
sys.getsizeof(('a long longlong string',))
64

元组的故事也是如此。 空元组的开销为56个字节，而列表的开销为72个字节。 同样，如果您的数据结构包含许多小的，不可变的序列，则每个序列的这16个字节的差异很容易实现。

sys.getsizeof(set())
232
sys.getsizeof(set([1))
232
sys.getsizeof(set([1, 2, 3, 4]))
232sys.getsizeof({})
280
sys.getsizeof(dict(a=1))
280
sys.getsizeof(dict(a=1, b=2, c=3))
280

集合和字典在添加项目时表面上根本不会增长，但是请注意巨大的开销。

最重要的是，Python对象具有巨大的固定开销。 如果您的数据结构由大量的集合对象（例如字符串，列表和字典）组成，并且每个对象都包含少量项目，那么您将付出沉重的代价。

deep_getsizeof（）函数

既然我已经吓到您半死了，并且还证明了sys.getsizeof（）只能告诉您原始对象需要多少内存，让我们来看一个更合适的解决方案。 deep_getsizeof（）函数以递归方式向下钻取并计算Python对象图的实际内存使用情况。

from collections import Mapping, Container
from sys import getsizeofdef deep_getsizeof(o, ids):"""Find the memory footprint of a Python objectThis is a recursive function that drills down a Python object graphlike a dictionary holding nested dictionaries with lists of listsand tuples and sets.The sys.getsizeof function does a shallow size of only. It counts eachobject inside a container as pointer only regardless of how big itreally is.:param o: the object:param ids::return:"""d = deep_getsizeofif id(o) in ids:return 0r = getsizeof(o)ids.add(id(o))if isinstance(o, str) or isinstance(0, unicode):return rif isinstance(o, Mapping):return r + sum(d(k, ids) + d(v, ids) for k, v in o.iteritems())if isinstance(o, Container):return r + sum(d(x, ids) for x in o)return r

此功能有几个有趣的方面。 它考虑了多次引用的对象，并且通过跟踪对象ID仅对它们进行一次计数。 该实现的另一个有趣特征是，它充分利用了collections模块的抽象基类 。 这使函数可以非常简洁地处理实现Mapping或Container基类的任何集合，而不是直接处理无数个集合类型，例如：字符串，Unicode，字节，列表，元组，dict，frozendict，OrderedDict，set，frozenset等。 。

让我们看看它的作用：

x = '1234567'
deep_getsizeof(x, set())
44

长度为7的字符串占用44个字节（37个开销+每个字符7个字节）。

deep_getsizeof([], set())
72

空列表占用72个字节（仅开销）。

deep_getsizeof([x], set())
124

包含字符串x的列表占用124个字节（72 + 8 + 44）。

deep_getsizeof([x, x, x, x, x], set())
156

包含字符串x 5的列表需要156个字节（72 + 5 * 8 + 44）。

最后一个示例显示deep_getsizeof（）仅对对同一对象（x字符串）的引用计数一次，但是对每个引用的指针进行计数。

对待或技巧

事实证明，CPython有很多技巧，因此从deep_getsizeof（）获得的数字不能完全代表Python程序的内存使用情况。

参考计数

Python使用引用计数语义来管理内存。 一旦不再引用对象，则将其内存释放。 但是，只要有引用，就不会释放该对象。 诸如循环引用之类的事情可能会给您带来极大的麻烦。

小物件

CPython在8字节边界的特殊池中管理小对象（少于256字节）。 有1-8个字节，9-16个字节以及一直到249-256个字节的池。 分配大小为10的对象时，将从16字节池中为大小为9-16字节的对象分配对象。 因此，即使它仅包含10个字节的数据，也将花费16个字节的内存。 如果分配1,000,000个大小为10的对象，则实际上使用16,000,000个字节，而不是您可能假定的10,000,000个字节。 这60％的开销显然是不平凡的。

整数

CPython保留[-5，256]范围内所有整数的全局列表。 这种优化策略是有道理的，因为到处都会弹出小整数，并且每个整数占用24个字节，因此它为典型程序节省了大量内存。

这也意味着CPython将为所有这些整数预分配266 * 24 = 6384字节，即使您不使用它们中的大多数也是如此。 您可以使用提供指向实际对象的指针的id（）函数进行验证。 如果对[-5，256]范围内的任何x调用id（x）的倍数，则每次都会得到相同的结果（对于相同的整数）。 但是，如果对超出此范围的整数进行尝试，则每个整数都会有所不同（每次都会动态创建一个新对象）。

以下是该范围内的一些示例：

id(-3)
140251817361752id(-3)
140251817361752id(-3)
140251817361752id(201)
140251817366736id(201)
140251817366736id(201)
140251817366736

以下是一些超出范围的示例：

id(301)
140251846945800id(301)
140251846945776id(-6)
140251846946960id(-6)
140251846946936

Python内存与系统内存

CPython是一种所有格。 在许多情况下，当不再引用程序中的内存对象时，它们不会返回给系统（例如，小对象）。 如果您分配和取消分配许多对象（属于相同的8字节池），这对您的程序很有用，因为Python不必打扰系统，这相对昂贵。 但是，如果您的程序通常使用X字节，并且在某些临时条件下使用的字节数不是100倍（例如，仅在启动时解析和处理大的配置文件），那不是很好。

现在，该100X内存可能被无用地捕获在您的程序中，不再被使用，并且拒绝系统将其分配给其他程序。 具有讽刺意味的是，如果使用处理模块来运行程序的多个实例，则会严重限制可在给定机器上运行的实例数量。

内存分析器

要评估和衡量程序的实际内存使用量，可以使用memory_profiler模块。 我玩了一点，但不确定我是否相信结果。 使用它非常简单。 用@profiler装饰器装饰一个函数（可以是main（0函数）），当程序退出时，内存分析器向标准输出打印一个方便的报告，该报告显示每行的内存总量和变化。我在分析器下运行的程序：

from memory_profiler import profile@profile
def main():a = []b = []c = []for i in range(100000):a.append(5)for i in range(100000):b.append(300)for i in range(100000):c.append('123456789012345678901234567890')del adel bdel cprint 'Done!'
if __name__ == '__main__':main()

这是输出：

Line #    Mem usage    Increment   Line Contents
================================================3     22.9 MiB      0.0 MiB   @profile4                             def main():5     22.9 MiB      0.0 MiB       a = []6     22.9 MiB      0.0 MiB       b = []7     22.9 MiB      0.0 MiB       c = []8     27.1 MiB      4.2 MiB       for i in range(100000):9     27.1 MiB      0.0 MiB           a.append(5)10     27.5 MiB      0.4 MiB       for i in range(100000):11     27.5 MiB      0.0 MiB           b.append(300)12     28.3 MiB      0.8 MiB       for i in range(100000):13     28.3 MiB      0.0 MiB           c.append('123456789012345678901234567890')14     27.7 MiB     -0.6 MiB       del a15     27.9 MiB      0.2 MiB       del b16     27.3 MiB     -0.6 MiB       del c1718     27.3 MiB      0.0 MiB       print 'Done!'

如您所见，有22.9 MB的内存开销。 在[-5，256]范围内外添加整数时以及在添加字符串时内存均不增加的原因是在所有情况下都使用单个对象。 目前尚不清楚为什么第8行的range（100000）的第一个循环添加4.2MB，而第10行的第二个循环仅添加0.4MB而第12行的第三个循环添加0.8MB。 最后，删除a，b和c列表时，a和c释放-0.6MB，而b添加0.2MB。 从这些结果中我无法理解。

结论

CPython为其对象使用大量内存。 它使用各种技巧和优化来进行内存管理。 通过跟踪对象的内存使用情况并了解内存管理模型，可以显着减少程序的内存占用量。

无论您是刚刚起步还是想学习新技能的经验丰富的程序员，都可以通过我们完整的python教程指南学习Python。

翻译自: https://code.tutsplus.com/tutorials/understand-how-much-memory-your-python-objects-use--cms-25609