在Python中准确测量对象大小-Sys.GetSizeOf不起作用 [英] Measure Object Size Accurately in Python - Sys.GetSizeOf not functioning

问题描述

我试图准确/确定地找到Python中两个不同类之间的大小差异.它们都是新的样式类，只是其中一个没有定义 slot .我尝试了许多测试来确定它们的大小差异，但是它们最终在内存使用上总是相同的.

I am trying to accurately/definitively find the size differences between two different classes in Python. They are both new style classes, save for one not having slots defined. I have tried numerous tests to determine their size difference, but they always end up being identical in memory usage.

到目前为止，我已经尝试了sys.GetSizeOf(obj)和heapy的heap()函数，但没有得到积极的结果.测试代码如下:

So far I have tried sys.GetSizeOf(obj) and heapy's heap() function, with no positive results. Test code is below:

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来确定大小，但这并不会产生任何不同的结果:

This is all with Python 2.6.0. I also attempted to override the class's sizeof methods to try determine the size by summing the individual sizeofs but that didn't yield any different results:

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

推荐答案

sys.getsizeof返回的数字比人们想象的更专业，用处更少.实际上，如果将属性数量增加到六个，则test3_obj仍为32，但是test4_obj跳至48个字节.这是因为getsizeof返回实现该类型的PyObject结构的大小，对于test3_obj，它不包含保存属性的字典，但是对于test4_obj，属性未存储在字典中，而是存储在插槽中，因此它们是按尺寸计算的.

sys.getsizeof returns a number which is more specialized and less useful than people think. In fact, if you increase the number of attributes to six, your test3_obj remains at 32, but test4_obj jumps to 48 bytes. This is because getsizeof is returning the size of the PyObject structure implementing the type, which for test3_obj doesn't include the dict holding the attributes, but for test4_obj, the attributes aren't stored in a dict, they are stored in slots, so they are accounted for in the size.

但是，用__slots__定义的类要比不使用此类的类占用更少的内存，这恰恰是因为没有保留属性的命令.

But a class defined with __slots__ takes less memory than a class without, precisely because there is no dict to hold the attributes.

为什么要覆盖__sizeof__?您真正要完成的任务是什么?

Why override __sizeof__? What are you really trying to accomplish?

这篇关于在Python中准确测量对象大小-Sys.GetSizeOf不起作用的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！