파이썬에서 문자열, 정수 등과 같은 객체의 크기를 얻는 방법을 알고 싶습니다.

관련 질문 : 파이썬 목록 (튜플)에 요소 당 몇 바이트가 있습니까?

값 크기를 지정하는 크기 필드가 포함 된 XML 파일을 사용하고 있습니다. 이 XML을 구문 분석하고 코딩을 수행해야합니다. 특정 필드의 값을 변경하려면 해당 값의 크기 필드를 확인합니다. 여기서 입력하려는 새 값이 XML과 동일한 크기인지 비교하고 싶습니다. 새로운 가치의 크기를 확인해야합니다. 문자열의 경우 길이를 말할 수 있습니다. 그러나 int, float 등의 경우 혼란 스럽습니다.

모듈에 정의 된 sys.getsizeof 함수를 사용하십시오 sys.

sys.getsizeof(object[, default]):

객체의 크기를 바이트 단위로 반환합니다. 객체는 모든 유형의 객체 일 수 있습니다. 모든 내장 개체는 올바른 결과를 반환하지만 구현에 따라 타사 확장에 해당되는 것은 아닙니다.

default인수는 오브젝트 유형이 크기를 검색하는 방법을 제공하지 않는과를 야기하는 경우 반환되는 값을 정의 할 수 있습니다 TypeError.

getsizeof__sizeof__가비지 수집기에서 개체를 관리하는 경우 개체의 메서드를 호출하고 가비지 수집기 오버 헤드를 추가합니다.

파이썬 3.0에서 사용 예 :

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

파이썬 <2.6에 있고없는 경우이 광범위한 모듈을 대신 sys.getsizeof사용할 수 있습니다 . 그래도 사용하지 마십시오.

파이썬에서 객체의 크기를 어떻게 결정합니까?

"sys.getsizeof 만 사용하십시오"라는 대답은 완전한 대답이 아닙니다.

이 답변 은 내장 객체에 직접 작동하지만 해당 객체에 포함 할 수있는 내용, 특히 사용자 정의 객체, 튜플, 목록, 받아쓰기 및 집합과 같은 유형을 설명하지는 않습니다. 숫자, 문자열 및 기타 객체뿐만 아니라 서로 인스턴스를 포함 할 수 있습니다.

더 완전한 답변

Anaconda 배포판의 64 비트 Python 3.6을 sys.getsizeof와 함께 사용하여 다음 객체의 최소 크기를 결정했으며 사전 할당 공간을 설정하고 지정하여 빈 공간이 설정된 양 이후까지 다시 커지지 않도록주의하십시오. 언어의 구현에 따라 다름) :

파이썬 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 바이트입니다.

함수 및 클래스 정의에 대한 몇 가지주의 사항 :

각 클래스 정의에는 __dict__클래스 attr에 대한 프록시 (48 바이트) 구조가 있습니다. 각 슬롯에는 property클래스 정의에 설명자와 같은 설명자가 있습니다.

슬롯 형 인스턴스는 첫 번째 요소에서 48 바이트로 시작하여 추가 할 때마다 8 씩 증가합니다. 빈 슬롯 객체 만 16 바이트이며 데이터가없는 인스턴스는 거의 이해가되지 않습니다.

또한 각 함수 정의에는 코드 객체, 아마도 docstring 및 기타 가능한 속성이 __dict__있습니다.

또한 우리 는 docs에서sys.getsizeof() 객체의 가비지 수집 오버 헤드를 포함하여 한계 공간 사용을 고려 하기 때문에 사용 합니다 .

getsizeof () __sizeof__는 객체가 가비지 수집기에 의해 관리되는 경우 객체의 메서드를 호출하고 추가 가비지 수집기 오버 헤드를 추가합니다.

또한 목록 크기를 조정하면 (예 : 반복적으로 목록에 추가) 세트 및 받아쓰기와 마찬가지로 공간을 미리 할당합니다. 로부터 listobj.c 소스 코드 :

    /* This over-allocates proportional to the list size, making room
     * for additional growth.  The over-allocation is mild, but is
     * enough to give linear-time amortized behavior over a long
     * sequence of appends() in the presence of a poorly-performing
     * system realloc().
     * The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
     * Note: new_allocated won't overflow because the largest possible value
     *       is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
     */
    new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6);

역사적 자료

로 확인 파이썬 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.

파이썬 3.6 에서는 사전 ( 그러나 세트는 아님)이 더 간결하게 표현 되었습니다.

추가 항목 당 8 바이트는 64 비트 시스템에서 많은 의미가 있다고 생각합니다. 이 8 바이트는 포함 된 항목이있는 메모리의 위치를 ​​가리 킵니다. 4 바이트는 파이썬 2에서 유니 코드의 고정 너비입니다. 정확하게 기억한다면 파이썬 3에서는 str이 문자의 최대 너비와 동일한 너비의 유니 코드가됩니다.

(그리고 슬롯에 대한 자세한 내용은이 답변을 참조하십시오 )

보다 완전한 기능

우리는 목록, 튜플, 세트, ​​딕트 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

이 구현은 모든 속성을 따르지 않기 때문에 클래스 정의와 함수 정의에 대해 세분화되지만 프로세스의 메모리에 한 번만 존재해야하므로 크기는 실제로 중요하지 않습니다.

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

으로 언급 ,

옵션을 설정하여 클래스, 함수, 메서드, 모듈 등과 같은 객체의 바이트 크기를 포함 할 수 있습니다 code=True.

라이브 데이터에 대한 다른 견해가 필요하다면 Pympler 's

모듈 muppy은 Python 응용 프로그램의 온라인 모니터링에 사용되며 모듈 Class Tracker은 선택한 Python 객체의 수명에 대한 오프라인 분석을 제공합니다.

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

Python 3.8 (2019 년 1 분기)은 Raymond Hettinger가 발표sys.getsizeof 한대로 일부 결과를 변경합니다 .

Python 컨테이너는 64 비트 빌드에서 8 바이트 작습니다.

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

이것은 33597 호 와 이나 다 나오키 ( methane) 의 Compact PyGC_Head와 PR 7043에 대한 연구 후에 나온다.

이 아이디어는 PyGC_Head 크기를 두 단어로 줄 입니다.

현재 PyGC_Head는 세 단어를 사용합니다 . gc_prev, gc_next및 gc_refcnt.

• gc_refcnt 시험 삭제를 위해 수집 할 때 사용됩니다.
• gc_prev 추적 및 추적 해제에 사용됩니다.

그래서 우리는 재판을 삭제하는 동안 untracking 추적 / 피할 수있는 경우 gc_prev와 gc_refcnt같은 메모리 공간을 공유 할 수 있습니다.

커밋 d5c875b 참조 :

Py_ssize_t에서 회원 1 명을 삭제 했습니다 PyGC_Head.
모든 GC 추적 객체 (예 : 튜플, 목록, dict) 크기는 4 또는 8 바이트로 줄어 듭니다.

계산 방법에 따라 보이는 것보다 복잡 할 수 있습니다. 예를 들어, 정수 목록이있는 경우 참조가 포함 된 목록의 크기를 원하십니까 가 하십니까? (즉, 여기에 포함 된 내용이 아닌 목록 만 표시) 또는 실제 참조를 포함시키려는 경우, 중복 참조를 처리해야하는 경우와 두 객체에 대한 참조가 포함 된 경우 이중 계산을 방지하는 방법 같은 객체.

pysizer 와 같은 python 메모리 프로파일 러 중 하나를 살펴보고 자신의 요구를 충족하는지 확인할 수 있습니다.

이 문제를 여러 번 겪으면서 작은 함수 (@ aaron-hall의 답변에서 영감을 얻음) 및 sys.getsizeof가 기대했던 것을 수행하는 테스트를 작성했습니다.

https://github.com/bosswissam/pysize

배경 이야기에 관심이 있다면 여기 있습니다.

편집 : 쉽게 참조 할 수 있도록 아래 코드를 첨부하십시오. 최신 코드를 보려면 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)) )

객체의 크기와 밀접한 관련이있는 측정 값을 도출하기 위해 객체를 직렬화 할 수 있습니다.

import pickle

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

(예 : 람다 식으로 인해) 피클 할 수없는 객체를 측정하려는 경우 cloudpickle이 해결책이 될 수 있습니다.

연결된 (중첩 된) 객체의 크기를 포함하지 않으려면 sys.getsizeof ()를 사용하십시오 .

그러나 목록, dicts, sets, tuples에 중첩 된 하위 객체를 계산하려는 경우 일반적으로 THIS는 다음과 같이 재귀 적 deep sizeof () 함수를 사용하십시오 .

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

이 유용한 기능은 다른 유용한 단일 라이너와 함께 멋진 도구 상자 에서 찾을 수 있습니다 .

https://github.com/mwojnars/nifty/blob/master/util.py

객체의 정확한 크기가 필요하지 않지만 대략 얼마나 큰지 아는 경우, 빠르고 빠른 방법 중 하나는 프로그램을 실행하고 장시간 잠을 자고 메모리 사용량을 확인하는 것입니다 (예 : :이 특정 파이썬 프로세스에 의한 Mac의 활동 모니터). 이것은 파이썬 프로세스에서 하나의 큰 객체의 크기를 찾으려고 할 때 효과적입니다. 예를 들어, 최근에 새로운 데이터 구조의 메모리 사용량을 확인하고이를 파이썬의 설정된 데이터 구조의 메모리 사용량과 비교하려고했습니다. 먼저 요소 (대형 퍼블릭 도메인 도서의 단어)를 세트에 쓴 다음 프로세스의 크기를 확인한 다음 다른 데이터 구조와 동일한 작업을 수행했습니다. 세트가있는 Python 프로세스가 새로운 데이터 구조보다 두 배의 메모리를 차지한다는 것을 알았습니다. 다시, 당신은 프로세스가 사용하는 메모리가 객체의 크기와 정확히 같다고 말할 수는 없습니다. 객체의 크기가 커짐에 따라 나머지 프로세스에서 소비하는 메모리는 모니터링하려는 객체의 크기와 비교하여 무시할 수있을 정도로 가까워집니다.

아래에 언급 된대로 getSizeof ()를 사용하여 객체의 크기를 결정할 수 있습니다.

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

이 트릭을 사용합니다 ... 작은 객체에서는 정확하지 않을 수도 있지만 sys.getsizeof () 대신 복잡한 파이 게임 표면과 같은 복잡한 객체에서는 훨씬 더 정확하다고 생각합니다

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

내 Windows 10, python 3.7.3에서 출력은 다음과 같습니다.

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