摘要：问题描述：有没有关于32位和64位平台上Python数据结构的内存大小的参考？如果没有，那么最好把它放在 SO 上。越详尽越好！那么以下 Python 结构使用了多少字节（取决于len和相关内容类型）？intfloat参考strunicode 字符串tuplelistdictsetarray.arraynum...

问题描述：

有没有关于32位和64位平台上Python数据结构的内存大小的参考？

如果没有，那么最好把它放在 SO 上。越详尽越好！那么以下 Python 结构使用了多少字节（取决于len和相关内容类型）？

int
float
参考
str
unicode 字符串
tuple
list
dict
set
array.array
numpy.array
deque
新式类对象
旧式类对象
...我忘记了一切！

（对于仅保留对其他对象的引用的容器，我们显然不想计算项目本身的大小，因为它可能是共享的。）

此外，有没有办法获取对象在运行时使用的内存（递归或非递归）？

解决方案 1：

先前问题中对此的建议是使用sys.getsizeof()，引用：

>>> import sys
>>> x = 2
>>> sys.getsizeof(x)
14
>>> sys.getsizeof(sys.getsizeof)
32
>>> sys.getsizeof('this')
38
>>> sys.getsizeof('this also')
48

您可以采取这种方法：

>>> import sys
>>> import decimal
>>> 
>>> d = {
...     "int": 0,
...     "float": 0.0,
...     "dict": dict(),
...     "set": set(),
...     "tuple": tuple(),
...     "list": list(),
...     "str": "a",
...     "unicode": u"a",
...     "decimal": decimal.Decimal(0),
...     "object": object(),
... }
>>> for k, v in sorted(d.iteritems()):
...     print k, sys.getsizeof(v)
...
decimal 40
dict 140
float 16
int 12
list 36
object 8
set 116
str 25
tuple 28
unicode 28

2012-09-30

Python 2.7（Linux，32位）：

decimal 36
dict 136
float 16
int 12
list 32
object 8
set 112
str 22
tuple 24
unicode 32

python 3.3（Linux，32 位）

decimal 52
dict 144
float 16
int 14
list 32
object 8
set 112
str 26
tuple 24
unicode 26

2016-08-01

OSX，Python 2.7.10（默认，2015 年 10 月 23 日，19:19:21）[GCC 4.2.1 兼容 Apple LLVM 7.0.0（clang-700.0.59.5）] 位于 darwin 上

decimal 80
dict 280
float 24
int 24
list 72
object 16
set 232
str 38
tuple 56
unicode 52

解决方案 2：

这些答案都收集了浅显的尺寸信息。我怀疑这个问题的访问者最终会在这里寻找答案：“这个复杂对象在内存中有多大？”

这里有一个很好的答案：https://goshippo.com/blog/measure-real-size-any-python-object/

妙趣横生：

import sys

def get_size(obj, seen=None):
    """Recursively finds size of objects"""
    size = sys.getsizeof(obj)
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    # Important mark as seen *before* entering recursion to gracefully handle
    # self-referential objects
    seen.add(obj_id)
    if isinstance(obj, dict):
        size += sum([get_size(v, seen) for v in obj.values()])
        size += sum([get_size(k, seen) for k in obj.keys()])
    elif hasattr(obj, '__dict__'):
        size += get_size(obj.__dict__, seen)
    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
        size += sum([get_size(i, seen) for i in obj])
    return size

使用方式如下：

In [1]: get_size(1)
Out[1]: 24

In [2]: get_size([1])
Out[2]: 104

In [3]: get_size([[1]])
Out[3]: 184

如果你想更深入地了解 Python 的内存模型，这里有一篇很棒的文章，其中有类似的“总大小”代码片段作为更长解释的一部分：https://code.tutsplus.com/tutorials/understand-how-much-memory-your-python-objects-use--cms-25609

解决方案 3：

我一直很高兴使用pympler来完成此类任务。它与许多版本的 Python 兼容 -asizeof特别是模块可以追溯到 2.2！

例如，使用 hughdbrown 的示例，但from pympler import asizeof在开始和print asizeof.asizeof(v)结束时，我看到（MacOSX 10.5 上的系统 Python 2.5）：

$ python pymp.py 
set 120
unicode 32
tuple 32
int 16
decimal 152
float 16
list 40
object 0
dict 144
str 32

显然这里有一些近似，但我发现它对于足迹分析和调整非常有用。

解决方案 4：

尝试内存分析器。
内存分析器

Line #    Mem usage  Increment   Line Contents
==============================================
     3                           @profile
     4      5.97 MB    0.00 MB   def my_func():
     5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
     6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
     7     13.61 MB -152.59 MB       del b
     8     13.61 MB    0.00 MB       return a

解决方案 5：

您也可以使用guppy模块。

>>> from guppy import hpy; hp=hpy()
>>> hp.heap()
Partition of a set of 25853 objects. Total size = 3320992 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0  11731  45   929072  28    929072  28 str
     1   5832  23   469760  14   1398832  42 tuple
     2    324   1   277728   8   1676560  50 dict (no owner)
     3     70   0   216976   7   1893536  57 dict of module
     4    199   1   210856   6   2104392  63 dict of type
     5   1627   6   208256   6   2312648  70 types.CodeType
     6   1592   6   191040   6   2503688  75 function
     7    199   1   177008   5   2680696  81 type
     8    124   0   135328   4   2816024  85 dict of class
     9   1045   4    83600   3   2899624  87 __builtin__.wrapper_descriptor
<90 more rows. Type e.g. '_.more' to view.>

和：

>>> hp.iso(1, [1], "1", (1,), {1:1}, None)
Partition of a set of 6 objects. Total size = 560 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0      1  17      280  50       280  50 dict (no owner)
     1      1  17      136  24       416  74 list
     2      1  17       64  11       480  86 tuple
     3      1  17       40   7       520  93 str
     4      1  17       24   4       544  97 int
     5      1  17       16   3       560 100 types.NoneType

解决方案 6：

当你使用dir([object])内置函数时，你可以获取__sizeof__内置函数的。

>>> a = -1
>>> a.__sizeof__()
24

解决方案 7：

你也可以使用tracemallocPython 标准库中的模块。它似乎对那些类用 C 实现的对象很有效（例如，与 Pympler 不同）。

解决方案 8：

更准确的递归 get_size

考虑打开的文件`slots`和 MemoryView 对象

虽然我自己已经在这里使用过这个模式几次，并从头开始重写了它，但今天我需要它来处理一些具有一些边缘情况的对象 -

由于谷歌在寻找 Python 递归 getsizeof 时在这里提供了一个，我认为如果可以在这里找到这个处理边缘情况的版本，它可以对一些人有所帮助。

根据@Kobold 的原始https://stackoverflow.com/a/40880923/108205答案

import sys
from collections.abc import Mapping, Sequence
from _io import _IOBase

exclude_sequences = (bytes, str, bytearray, _IOBase, memoryview)

def get_size(obj, seen=None):
    """Recursively finds size of objects"""
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    size = sys.getsizeof(obj)
    # Important mark as seen *before* entering recursion to gracefully handle
    # self-referential objects
    seen.add(obj_id)
    if isinstance(obj, dict):
        size += sum([get_size(v, seen) for v in obj.values()])
        size += sum([get_size(k, seen) for k in obj.keys()])
    elif hasattr(obj, '__dict__'):
        size += get_size(obj.__dict__, seen)
    elif isinstance(obj, memoryview):
        size += get_size(obj.obj, seen)  # this way the memoryview target is taken in account in the "seen" mechanism"
    elif hasattr(obj, '__iter__') and not isinstance(obj, exclude_sequences):
        size += sum([get_size(i, seen) for i in obj])
    if hasattr(obj, "__slots__"):
        for attrname in obj.__slots__:
            if attr:=getattr(obj, attrname, None):
                size += get_size(attr, seen)
    return size