在C中，我们可以找到int，char等的大小。我想知道如何在Python中获取对象的大小，如字符串，整数等。
相关问题：How many bytes per element are there in a Python list (tuple)?
我使用的XML文件包含指定值大小的大小字段。我必须解析这个XML并进行编码。当我想更改特定字段的值时，我将检查该值的大小字段。在这里，我想比较一下我输入的新值是否与XML中的值相同。我需要检查新值的大小。在字符串的情况下，我可以说它的长度。但是在int，float等的情况下我很困惑。
只需使用sys.getsizeof模块中定义的sys函数。
sys.getsizeof(object[, default])：以字节为单位返回对象的大小。对象可以是任何类型的对象。所有内置对象都将返回正确的结果，但这不一定适用于第三方扩展，因为它是特定于实现的。
default参数允许定义一个值，如果对象类型没有提供检索大小的方法并且会导致TypeError，则返回该值。
getsizeof调用对象的__sizeof__方法，如果对象由垃圾收集器管理，则会增加额外的垃圾收集器开销。
用法示例，在python 3.0中：
>>> import sys
>>> x = 2
>>> sys.getsizeof(x)
24
>>> sys.getsizeof(sys.getsizeof)
32
>>> sys.getsizeof('this')
38
>>> sys.getsizeof('this also')
48
如果你在python <2.6并且没有sys.getsizeof，你可以使用this extensive module代替。从来没有用过它。
第一：答案。
import sys
try: print sys.getsizeof(object)
except AttributeError:
print "sys.getsizeof exists in Python ≥2.6"
讨论： 在Python中，您无法访问“直接”内存地址。那么，为什么你需要或想要知道给定对象占用了多少这样的地址？这个抽象层次的问题完全不合适。当你在画你的房子时，你不会问漆的每个组成原子吸收或反射的光的频率，你只要问它是什么颜色 - 产生这种颜色的物理特征的细节与此无关。类似地，给定Python对象占用的内存字节数不在此处。
那么，为什么要尝试使用Python编写C代码？ :)
How do I determine the size of an object in Python?
答案“只使用sys.getsizeof”并不是一个完整的答案。
该答案直接适用于内置对象，但它没有考虑这些对象可能包含的内容，特别是自定义对象，元组，列表，字符串和集合等类型。它们可以包含彼此的实例，以及数字，字符串和其他对象。
使用来自Anaconda发行版的64位Python 3.6，使用sys.getsizeof，我确定了以下对象的最小大小，并注意set和dicts预分配空间，因此空的不会再次增长，直到设定量（可能因语言的实现而有所不同）：
Python 3：
Empty
Bytes type scaling notes
28 int +4 bytes about every 30 powers of 2
37 bytes +1 byte per additional byte
49 str +1-4 per additional character (depending on max width)
48 tuple +8 per additional item
64 list +8 for each additional
224 set 5th increases to 736; 21nd, 2272; 85th, 8416; 341, 32992
240 dict 6th increases to 368; 22nd, 1184; 43rd, 2280; 86th, 4704; 171st, 9320
136 func def does not include default args and other attrs
1056 class def no slots
56 class inst has a __dict__ attr, same scaling as dict above
888 class def with slots
16 __slots__ seems to store in mutable tuple-like structure
first slot grows to 48, and so on.
你怎么解释这个？好吧，你有一套10件物品。如果每个项目每个100字节，整个数据结构有多大？该集合本身就是736，因为它的大小为736字节。然后添加项目的大小，总共1736个字节
函数和类定义的一些注意事项：
注意每个类定义都有类attrs的代理__dict__（48字节）结构。每个槽在类定义中都有一个描述符（如property）。
Slotted实例在其第一个元素上以48个字节开始，每增加8个字节。只有空的开槽对象有16个字节，而没有数据的实例几乎没有意义。
此外，每个函数定义都有代码对象，可能是文档字符串，以及其他可能的属性，甚至是__dict__。
Python 2.7分析，用guppy.hpy和sys.getsizeof确认：
Bytes type empty + scaling notes
24 int NA
28 long NA
37 str + 1 byte per additional character
52 unicode + 4 bytes per additional character
56 tuple + 8 bytes per additional item
72 list + 32 for first, 8 for each additional
232 set sixth item increases to 744; 22nd, 2280; 86th, 8424
280 dict sixth item increases to 1048; 22nd, 3352; 86th, 12568 *
120 func def does not include default args and other attrs
64 class inst has a __dict__ attr, same scaling as dict above
16 __slots__ class with slots has no dict, seems to store in
mutable tuple-like structure.
904 class def has a proxy __dict__ structure for class attrs
104 old class makes sense, less stuff, has real dict though.
请注意，词典（but not sets）在Python 3.6中获得了more compact representation
我认为每个附加项目的8个字节在64位机器上很有意义。这8个字节指向包含项目所在的内存中的位置。如果我没记错的话，4字节是Python 2中unicode的固定宽度，但在Python 3中，str变成宽度等于字符最大宽度的unicode。
（有关插槽的更多信息，see this answer）
我们想要一个函数来搜索列表，元组，集合，dicts，obj.__dict__和obj.__slots__中的元素，以及我们可能还没有想到的其他东西。
我们希望依靠gc.get_referents来进行此搜索，因为它在C级工作（使其非常快）。缺点是get_referents可以返回冗余成员，因此我们需要确保不会重复计算。
类，模块和函数是单例 - 它们在内存中存在一次。我们对他们的规模并不那么感兴趣，因为我们对他们的影响不大 - 他们是该计划的一部分。因此，如果恰好引用它们，我们将避免对它们进行计数。
我们将使用类型的黑名单，因此我们不会将整个程序包含在我们的大小计数中。
import sys
from types import ModuleType, FunctionType
from gc import get_referents
# Custom objects know their class.
# Function objects seem to know way too much, including modules.
# Exclude modules as well.
BLACKLIST = type, ModuleType, FunctionType
def getsize(obj):
"""sum size of object & members."""
if isinstance(obj, BLACKLIST):
raise TypeError('getsize() does not take argument of type: '+ str(type(obj)))
seen_ids = set()
size = 0
objects = [obj]
while objects:
need_referents = []
for obj in objects:
if not isinstance(obj, BLACKLIST) and id(obj) not in seen_ids:
seen_ids.add(id(obj))
size += sys.getsizeof(obj)
need_referents.append(obj)
objects = get_referents(*need_referents)
return size
为了将其与下面的白名单函数进行对比，大多数对象都知道如何遍历垃圾收集的目的（当我们想知道某些对象在内存中有多昂贵时，这就是我们正在寻找的东西。这个功能由gc.get_referents。）但是，如果我们不小心，这项措施的范围将比我们预期的范围大得多。
例如，函数对它们所创建的模块有很多了解。
另一个对比点是作为字典中键的字符串通常被实现，因此它们不会重复。检查id(key)还可以让我们避免计算重复项，我们将在下一节中介绍。黑名单解决方案跳过完全计算字符串的计数键。
为了自己覆盖大多数类型，而不是依赖于gc模块，我编写了这个递归函数来尝试估计大多数Python对象的大小，包括大多数内置函数，集合模块中的类型和自定义类型（插槽和其他） 。
这种函数可以对我们计算内存使用量的类型进行更细粒度的控制，但是存在丢弃类型的危险：
import sys
from numbers import Number
from collections import Set, Mapping, deque
try: # Python 2
zero_depth_bases = (basestring, Number, xrange, bytearray)
iteritems = 'iteritems'
except NameError: # Python 3
zero_depth_bases = (str, bytes, Number, range, bytearray)
iteritems = 'items'
def getsize(obj_0):
"""Recursively iterate to sum size of object & members."""
_seen_ids = set()
def inner(obj):
obj_id = id(obj)
if obj_id in _seen_ids:
return 0
_seen_ids.add(obj_id)
size = sys.getsizeof(obj)
if isinstance(obj, zero_depth_bases):
pass # bypass remaining control flow and return
elif isinstance(obj, (tuple, list, Set, deque)):
size += sum(inner(i) for i in obj)
elif isinstance(obj, Mapping) or hasattr(obj, iteritems):
size += sum(inner(k) + inner(v) for k, v in getattr(obj, iteritems)())
# Check for custom object instances - may subclass above too
if hasattr(obj, '__dict__'):
size += inner(vars(obj))
if hasattr(obj, '__slots__'): # can have __slots__ with __dict__
size += sum(inner(getattr(obj, s)) for s in obj.__slots__ if hasattr(obj, s))
return size
return inner(obj_0)
而且我很随便地测试它（我应该对它进行单元测试）：
>>> getsize(['a', tuple('bcd'), Foo()])
344
>>> getsize(Foo())
16
>>> getsize(tuple('bcd'))
194
>>> getsize(['a', tuple('bcd'), Foo(), {'foo': 'bar', 'baz': 'bar'}])
752
>>> getsize({'foo': 'bar', 'baz': 'bar'})
400
>>> getsize({})
280
>>> getsize({'foo':'bar'})
360
>>> getsize('foo')
40
>>> class Bar():
... def baz():
... pass
>>> getsize(Bar())
352
>>> getsize(Bar().__dict__)
280
>>> sys.getsizeof(Bar())
72
>>> getsize(Bar.__dict__)
872
>>> sys.getsizeof(Bar.__dict__)
280
这个实现分解了类定义和函数定义，因为我们不追求它们的所有属性，但由于它们应该只在内存中存在一次，因此它们的大小确实无关紧要。
对于numpy数组，getsizeof不起作用 - 对我而言，由于某种原因它总是返回40：
from pylab import *
from sys import getsizeof
A = rand(10)
B = rand(10000)
然后（在ipython中）：
In [64]: getsizeof(A)
Out[64]: 40
In [65]: getsizeof(B)
Out[65]: 40
但幸运的是：
In [66]: A.nbytes
Out[66]: 80
In [67]: B.nbytes
Out[67]: 80000
Pympler包的asizeof模块可以做到这一点。
使用方法如下：
from pympler import asizeof
asizeof.asizeof(my_object)
与sys.getsizeof不同，它适用于您自己创建的对象。它甚至适用于numpy。
>>> asizeof.asizeof(tuple('bcd'))
200
>>> asizeof.asizeof({'foo': 'bar', 'baz': 'bar'})
400
>>> asizeof.asizeof({})
280
>>> asizeof.asizeof({'foo':'bar'})
360
>>> asizeof.asizeof('foo')
40
>>> asizeof.asizeof(Bar())
352
>>> asizeof.asizeof(Bar().__dict__)
280
>>> A = rand(10)
>>> B = rand(10000)
>>> asizeof.asizeof(A)
176
>>> asizeof.asizeof(B)
80096
作为mentioned，
如果你需要有关实时数据的其他观点，那就是Pympler's
module
muppy用于在线监控Python应用程序和模块Class Tracker提供所选Python对象生命周期的离线分析。
这可能比看起来更复杂，具体取决于你想要计算的东西。例如，如果你有一个int列表，你想要包含对int的引用的列表的大小吗？ （即仅列出，不包含其中的内容），或者是否要包含指向的实际数据，在这种情况下，您需要处理重复的引用，以及当两个对象包含对引用的引用时如何防止重复计数同一个对象。
您可能需要查看其中一个python内存分析器，例如pysizer，看看它们是否满足您的需求。
我自己多次遇到这个问题，我写了一个小函数（灵感来自@ aaron-hall的答案）和测试，它做了我原本期望的sys.getsizeof：
https://github.com/bosswissam/pysize
如果你对背景故事感兴趣，here it is
编辑：附上以下代码以便于参考。要查看最新代码，请查看github链接。
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
这是我根据以前对所有变量列表大小的答案编写的快速脚本
for i in dir():
print (i, sys.getsizeof(eval(i)) )
Python 3.8（2019年第一季度）将改变sys.getsizeof的一些结果，如Raymond Hettinger的announced here所示：
在64位版本中，Python容器小8个字节。
tuple () 48 -> 40
list [] 64 ->56
set() 224 -> 216
dict {} 240 -> 232
这是在issue 33597和Inada Naoki (methane)围绕Compact PyGC_Head和PR 7043的工作之后发生的
这个想法将PyGC_Head大小减少到两个单词。
目前，PyGC_Head有三个字;
gc_prev，gc_next和gc_refcnt。
- 收集时使用
gc_refcnt，以便删除试验。gc_prev用于跟踪和跟踪。因此，如果我们可以在删除试验时避免跟踪/取消跟踪，
gc_prev和gc_refcnt可以共享相同的内存空间。
从
Py_ssize_t中删除了一名PyGC_Head成员。 所有GC跟踪对象（例如元组，列表，字典）的大小减少了4或8个字节。
如果你不需要对象的确切大小但大致知道它有多大，一种快速（和脏）的方法是让程序运行，长时间休眠，并检查内存使用情况（例如：Mac的活动监视器）由这个特殊的python进程。当您尝试在python进程中查找单个大对象的大小时，这将非常有效。例如，我最近想检查新数据结构的内存使用情况，并将其与Python的集合数据结构进行比较。首先，我将元素（来自大型公共领域书籍的单词）写入集合，然后检查进程的大小，然后对其他数据结构执行相同的操作。我发现带有一个集合的Python进程占用的内存是新数据结构的两倍。同样，您将无法确切地说该进程使用的内存等于对象的大小。随着对象的大小变大，这变得很接近，因为与您尝试监视的对象的大小相比，其余进程消耗的内存变得可以忽略不计。