我正在尝试准确/明确地找到Python中两个不同类之间的大小差异。它们都是新的样式类，除了没有定义插槽的类。我已经尝试了很多测试来确定它们的大小差异，但它们总是在内存使用方面完全相同。
到目前为止，我已经尝试过sys.GetSizeOf（obj）和heapy的heap（）函数，没有任何正面结果。测试代码如下：
import sys
from guppy import hpy
class test3(object):
def __init__(self):
self.one = 1
self.two = "two variable"
class test4(object):
__slots__ = ('one', 'two')
def __init__(self):
self.one = 1
self.two = "two variable"
test3_obj = test3()
print "Sizeof test3_obj", sys.getsizeof(test3_obj)
test4_obj = test4()
print "Sizeof test4_obj", sys.getsizeof(test4_obj)
arr_test3 = []
arr_test4 = []
for i in range(3000):
arr_test3.append(test3())
arr_test4.append(test4())
h = hpy()
print h.heap()
输出：
Sizeof test3_obj 32 Sizeof test4_obj 32 Partition of a set of 34717 objects. Total size = 2589028 bytes. Index Count % Size % Cumulative % Kind (class / dict of class) 0 11896 34 765040 30 765040 30 str 1 3001 9 420140 16 1185180 46 dict of __main__.test3 2 5573 16 225240 9 1410420 54 tuple 3 348 1 167376 6 1577796 61 dict (no owner) 4 1567 5 106556 4 1684352 65 types.CodeType 5 68 0 105136 4 1789488 69 dict of module 6 183 1 97428 4 1886916 73 dict of type 7 3001 9 96032 4 1982948 77 __main__.test3 8 3001 9 96032 4 2078980 80 __main__.test4 9 203 1 90360 3 2169340 84 type <99 more rows. Type e.g. '_.more' to view.>
这完全适用于Python 2.6.0。我还尝试覆盖类的 sizeof 方法，尝试通过对各个sizeofs求和来确定大小，但不会产生任何不同的结果：
class test4(object):
__slots__ = ('one', 'two')
def __init__(self):
self.one = 1
self.two = "two variable"
def __sizeof__(self):
return super(test4, self).__sizeof__() + self.one.__sizeof__() + self.two.__sizeof__()
覆盖 sizeof 方法的结果：
Sizeof test3_obj 80 Sizeof test4_obj 80
答案 0 :(得分：4)
sys.getsizeof会返回一个比人们想象的更专业，更有用的数字。实际上，如果将属性数增加到6，则test3_obj保持为32，但test4_obj会跳转到48个字节。这是因为getsizeof返回实现类型的PyObject结构的大小，这对于test3_obj不包含持有属性的dict，但对于test4_obj，属性不存储在dict中，它们存储在槽中，所以它们按大小计算。
但是用__slots__定义的类占用的内存少于没有类的内存，正是因为没有dict来保存属性。
为什么要覆盖__sizeof__？你真的想要完成什么？
答案 1 :(得分：1)
首先检查os'内存管理器中没有很多对象的Pyton进程的大小。
其次制作一种类型的物品并再次检查尺寸。
第三种制造另一种物体并检查尺寸。
重复几次，如果每个步骤的大小保持不变，那么你就会得到类似的东西。
答案 2 :(得分：1)
正如其他人所述，sys.getsizeof仅返回表示您的数据的对象结构的大小。因此，例如，如果您有一个不断向其添加元素的动态数组，则sys.getsizeof(my_array)将仅显示基础DynamicArray对象的大小，而不显示其元素占用的内存的增加
pympler.asizeof.asizeof()给出了大约完整大小的对象，可能对您来说更准确。
from pympler import asizeof
asizeof.asizeof(my_object) # should give you the full object size
答案 3 :(得分：0)
您可能希望使用不同的实现来获取内存中对象的大小：
>>> import sys, array
>>> sizeof = lambda obj: sum(map(sys.getsizeof, explore(obj, set())))
>>> def explore(obj, memo):
loc = id(obj)
if loc not in memo:
memo.add(loc)
yield obj
if isinstance(obj, memoryview):
yield from explore(obj.obj, memo)
elif not isinstance(obj, (range, str, bytes, bytearray, array.array)):
# Handle instances with slots.
try:
slots = obj.__slots__
except AttributeError:
pass
else:
for name in slots:
try:
attr = getattr(obj, name)
except AttributeError:
pass
else:
yield from explore(attr, memo)
# Handle instances with dict.
try:
attrs = obj.__dict__
except AttributeError:
pass
else:
yield from explore(attrs, memo)
# Handle dicts or iterables.
for name in 'keys', 'values', '__iter__':
try:
attr = getattr(obj, name)
except AttributeError:
pass
else:
for item in attr():
yield from explore(item, memo)
>>> class Test1:
def __init__(self):
self.one = 1
self.two = 'two variable'
>>> class Test2:
__slots__ = 'one', 'two'
def __init__(self):
self.one = 1
self.two = 'two variable'
>>> print('sizeof(Test1()) ==', sizeof(Test1()))
sizeof(Test1()) == 361
>>> print('sizeof(Test2()) ==', sizeof(Test2()))
sizeof(Test2()) == 145
>>> array_test1, array_test2 = [], []
>>> for _ in range(3000):
array_test1.append(Test1())
array_test2.append(Test2())
>>> print('sizeof(array_test1) ==', sizeof(array_test1))
sizeof(array_test1) == 530929
>>> print('sizeof(array_test2) ==', sizeof(array_test2))
sizeof(array_test2) == 194825
>>>
如果您想要回复，请确保不向此代码提供任何无限迭代器。
答案 4 :(得分：0)
我遇到了类似的问题，最后编写了自己的助手来完成肮脏的工作。查看here
答案 5 :(得分：0)
以下功能已在Python 3.6、64位系统中经过测试。 对我来说非常有用。 （我从互联网上拿起它，并根据自己的风格进行了调整， 并添加了“ 广告位”功能的使用。 我无法再次找到原始来源。）
def getSize(obj, seen: Optional[Set[int]] = None) -> int:
"""Recursively finds size of objects. Needs: import sys """
seen = set() if seen is None else seen
if id(obj) in seen: return 0 # to handle self-referential objects
seen.add(id(obj))
size = sys.getsizeof(obj, 0) # pypy3 always returns default (necessary)
if isinstance(obj, dict):
size += sum(getSize(v, seen) + getSize(k, seen) for k, v in obj.items())
elif hasattr(obj, '__dict__'):
size += getSize(obj.__dict__, seen)
elif hasattr(obj, '__slots__'): # in case slots are in use
slotList = [getattr(C, "__slots__", []) for C in obj.__class__.__mro__]
slotList = [[slot] if isinstance(slot, str) else slot for slot in slotList]
size += sum(getSize(getattr(obj, a, None), seen) for slot in slotList for a in slot)
elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
size += sum(getSize(i, seen) for i in obj)
return size
现在用于以下类的对象
class test3(object):
def __init__(self):
self.one = 1
self.two = "two variable"
class test4(object):
__slots__ = ('one', 'two')
def __init__(self):
self.one = 1
self.two = "two variable"
获得以下结果，
In [21]: t3 = test3()
In [22]: getSize(t3)
Out[22]: 361
In [23]: t4 = test4()
In [25]: getSize(t4)
Out[25]: 145
非常欢迎反馈以改进功能。