在Python中如何确定对象的大小？

我想知道如何在Python中获得字符串、整数等对象的大小

相关问题：

我使用的是一个XML文件，其中包含指定值大小的大小字段。我必须解析这个XML并进行编码。当我想要更改某个特定字段的值时，我将检查该值的大小字段。这里我想比较我要输入的新值是否与XML中的值大小相同。我需要检查新值的大小。如果是字符串，我可以说是长度。但是对于int、float等，我感到困惑。

只需使用

sys

模块中定义的函数即可

sys.getsizeof（对象[，默认]）

：

返回对象的大小（以字节为单位）。 对象可以是任何类型的对象。 所有内置对象都将返回 正确的结果，但这不正确 必须对第三方保持真实 实现时的扩展 具体的

只有直接归因于该对象的内存消耗才会被忽略 已计算，而不是它所指对象的内存消耗

default

参数允许定义 如果 对象类型不提供 检索大小并将导致

类型错误

getsizeof

调用对象的

\uuuu sizeof\uuuu

方法，并增加了额外的垃圾收集器开销 如果对象由 垃圾收集器

有关递归使用

getsizeof（）

查找容器大小及其所有内容的示例，请参见

使用示例，在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

，则可以使用。但从未使用过它。

这可能比它看起来更复杂，这取决于你想如何计算东西。例如，如果您有一个整数列表，是否需要包含对整数的引用的列表的大小？（即，仅列出，而不是其中包含的内容），或者您是否希望包含指向的实际数据，在这种情况下，您需要处理重复引用，以及当两个对象包含对同一对象的引用时，如何防止重复计数

---

您可能想看看其中一个python内存分析器，看看它们是否满足您的需要。

对于numpy数组，

getsizeof

不起作用-对于我来说，由于某些原因，它总是返回40：

from pylab import *
from sys import getsizeof
A = rand(10)
B = rand(10000)

然后（在ipython中）：

但令人高兴的是：

In [66]: A.nbytes
Out[66]: 80

In [67]: B.nbytes
Out[67]: 80000

---

下面是我根据前面的答案编写的一个快速脚本，用于列出所有变量的大小

for i in dir():
    print (i, sys.getsizeof(eval(i)) )

在Python中如何确定对象的大小？ 答案“只需使用

sys.getsizeof

”并不是一个完整的答案

这个答案确实直接适用于内置对象，但它没有说明这些对象可能包含哪些内容，特别是自定义对象、元组、列表、dict和集合等类型。它们可以包含彼此的实例，以及数字、字符串和其他对象

更完整的答案 使用Anaconda发行版中的64位Python 3.6，使用sys.getsizeof，我已经确定了以下对象的最小大小，并注意到集合和dict预分配了空间，因此空的空间在达到一定数量后才会再次增长（这可能因语言的实现而异）：

Python 3：

空
字节类型缩放注释
28整数+4字节，大约每30次2的幂
37字节+1字节/额外字节
每增加一个字符49 str+1-4（取决于最大宽度）
48个元组+每个附加项8个元组
64列表+8每增加一个
224套第5套增加到736套；第21届，2272；第85届，8416；341, 32992
第6版240条增加到368条；第二十二届，1184年；第43、2280条；第86届，4704；第171街，9320号
136 func def不包括默认参数和其他属性
1056级def无插槽
56类inst有一个dict属性，与上面的dict具有相同的缩放比例
888级def带插槽
16个插槽似乎存储在可变元组结构中
第一个插槽增长到48个，以此类推。

你如何解释这一点？好吧，假设你有一套里面有10件物品。如果每个项都是100字节，那么整个数据结构有多大？该集合本身是736，因为它的一次大小为736字节。然后添加项目的大小，总共是1736字节

函数和类定义的一些注意事项：

注意：每个类定义都有一个类属性的代理

\uuuuu dict\uuuuu

（48字节）结构。在类定义中，每个插槽都有一个描述符（如

属性

）

开槽实例的第一个元素上有48个字节，每增加一个字节就增加8个字节。只有空的时隙对象才有16个字节，没有数据的实例没有什么意义

此外，每个函数定义都有代码对象，可能是docstring和其他可能的属性，甚至是

\uuuu dict\uuu

还请注意，我们使用的是

sys.getsizeof（）

，因为我们关心的是边际空间的使用，其中包括对象的垃圾收集开销：

getsizeof（）

调用对象的

\uuuuuizeof\uuuuuu

方法并添加 如果对象由 垃圾收集器

还要注意的是，调整列表的大小（例如，重复添加列表）会导致它们预先分配空间，类似于集合和dict。从：

/*这与列表大小成比例的超额分配，腾出空间
*为了进一步的增长。这种过度分配是温和的，但也很严重
*足以在长期内产生线性时间摊销行为
*存在性能不佳的附件时的附件序列（）
*系统realloc（）。
*其生长模式为：0,4,8,16,25,35,46,58,72,88。。。
*注意：分配的新_不会溢出，因为最大可能的va
for i in dir():
    print (i, sys.getsizeof(eval(i)) )

from pympler import asizeof
asizeof.asizeof(my_object)

>>> 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

    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

tuple ()  48 -> 40       
list  []  64 ->56
set()    224 -> 216
dict  {} 240 -> 232

import sys
str1 = "one"
int_element=5
print("Memory size of '"+str1+"' = "+str(sys.getsizeof(str1))+ " bytes")
print("Memory size of '"+ str(int_element)+"' = "+str(sys.getsizeof(int_element))+ " bytes")

import sys
def sizeof(obj):
    size = sys.getsizeof(obj)
    if isinstance(obj, dict): return size + sum(map(sizeof, obj.keys())) + sum(map(sizeof, obj.values()))
    if isinstance(obj, (list, tuple, set, frozenset)): return size + sum(map(sizeof, obj))
    return size

import pickle

## let o be the object whose size you want to measure
size_estimate = len(pickle.dumps(o))

import pygame as pg
import os
import psutil
import time


process = psutil.Process(os.getpid())
pg.init()    
vocab = ['hello', 'me', 'you', 'she', 'he', 'they', 'we',
         'should', 'why?', 'necessarily', 'do', 'that']

font = pg.font.SysFont("monospace", 100, True)

dct = {}

newMem = process.memory_info().rss  # don't mind this line
Str = f'store ' + f'Nothing \tsurface use about '.expandtabs(15) + \
      f'0\t bytes'.expandtabs(9)  # don't mind this assignment too

usedMem = process.memory_info().rss

for word in vocab:
    dct[word] = font.render(word, True, pg.Color("#000000"))

    time.sleep(0.1)  # wait a moment

    # get total used memory of this script:
    newMem = process.memory_info().rss
    Str = f'store ' + f'{word}\tsurface use about '.expandtabs(15) + \
          f'{newMem - usedMem}\t bytes'.expandtabs(9)

    print(Str)
    usedMem = newMem

store hello          surface use about 225280    bytes
store me             surface use about 61440     bytes
store you            surface use about 94208     bytes
store she            surface use about 81920     bytes
store he             surface use about 53248     bytes
store they           surface use about 114688    bytes
store we             surface use about 57344     bytes
store should         surface use about 172032    bytes
store why?           surface use about 110592    bytes
store necessarily    surface use about 311296    bytes
store do             surface use about 57344     bytes
store that           surface use about 110592    bytes