Python 구조의 메모리 내 크기

Python 구조의 메모리 내 크기

32비트 및 64비트 플랫폼에서 Python 데이터 구조의 메모리 크기에 대한 참조가 있습니까?

만약 그렇지 않다면, 이것은 SO에 있으면 좋을 것입니다.철저할수록 좋습니다!따라서 다음 Python 구조에서 사용되는 바이트 수는 다음과 같습니다(에 따라 다름).len내용 유형(해당되는 경우)?

• int
• float
• 언급
• str
• 유니코드 문자열
• tuple
• list
• dict
• set
• array.array
• numpy.array
• deque
• 새 스타일 클래스 객체
• 오래된 스타일의 클래스 객체
• 그리고 내가 잊고 있는 모든 것들!

(다른 개체에 대한 참조만 보관하는 컨테이너의 경우, 항목 자체의 크기는 공유될 수 있으므로 계산하지 않는 것이 좋습니다.)

또한 런타임에 객체가 사용하는 메모리를 (재귀적으로) 가져올 수 있는 방법이 있습니까?

이에 대한 이전 질문의 권장 사항은 다음을 인용하여 sys.getsize of()를 사용하는 것이었습니다.

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

다음과 같은 접근 방식을 취할 수 있습니다.

>>> import sys
>>> import decimal
>>> 
>>> d = {
...     "int": 0,
...     "float": 0.0,
...     "dict": dict(),
...     "set": set(),
...     "tuple": tuple(),
...     "list": list(),
...     "str": "a",
...     "unicode": u"a",
...     "decimal": decimal.Decimal(0),
...     "object": object(),
... }
>>> for k, v in sorted(d.iteritems()):
...     print k, sys.getsizeof(v)
...
decimal 40
dict 140
float 16
int 12
list 36
object 8
set 116
str 25
tuple 28
unicode 28

---

2012-09-30

python 2.7(리눅스, 32비트):

decimal 36
dict 136
float 16
int 12
list 32
object 8
set 112
str 22
tuple 24
unicode 32

python 3.3(linux, 32비트)

decimal 52
dict 144
float 16
int 14
list 32
object 8
set 112
str 26
tuple 24
unicode 26

---

2016-08-01

OSX, Python 2.7.10 (기본값, 2015년 10월 23일, 19:19:21) [GCC 4.2.1 호환 Apple LLVM 7.0.0(clang-700.0.59.5)] on darwin

decimal 80
dict 280
float 24
int 24
list 72
object 16
set 232
str 38
tuple 56
unicode 52

이러한 답변은 모두 얕은 크기의 정보를 수집합니다.저는 이 질문에 대한 방문객들이 "이 복잡한 물체가 기억에 얼마나 큰가?"라는 질문에 답하기 위해 여기에 올 것이라고 생각합니다.

여기에 훌륭한 답변이 있습니다: https://goshippo.com/blog/measure-real-size-any-python-object/

펀치라인:

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

다음과 같이 사용:

In [1]: get_size(1)
Out[1]: 24

In [2]: get_size([1])
Out[2]: 104

In [3]: get_size([[1]])
Out[3]: 184

Python의 메모리 모델을 더 자세히 알고 싶다면, 긴 설명의 일부로 유사한 "총 크기" 코드 조각이 있는 훌륭한 기사가 있습니다. https://code.tutsplus.com/tutorials/understand-how-much-memory-your-python-objects-use--cms-25609

저는 그런 일들을 위해 핌플러를 행복하게 사용해왔습니다.이것은 많은 버전의 파이썬과 호환됩니다.asizeof특히 모듈은 2.2로 돌아갑니다!

예를 들어, Hughbrown의 예를 사용하지만 다음과 같이 사용합니다.from pympler import asizeof처음에print asizeof.asizeof(v)마지막에 (MacOSX 10.5의 시스템 Python 2.5):

$ python pymp.py 
set 120
unicode 32
tuple 32
int 16
decimal 152
float 16
list 40
object 0
dict 144
str 32

여기에는 분명히 약간의 근사치가 있지만, 저는 그것이 발자국 분석과 조정에 매우 유용하다는 것을 알게 되었습니다.

메모리 프로파일러를 사용해 보십시오. 메모리 프로파일러

Line #    Mem usage  Increment   Line Contents
==============================================
     3                           @profile
     4      5.97 MB    0.00 MB   def my_func():
     5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
     6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
     7     13.61 MB -152.59 MB       del b
     8     13.61 MB    0.00 MB       return a

또한 guppy 모듈을 사용할 수 있습니다.

>>> from guppy import hpy; hp=hpy()
>>> hp.heap()
Partition of a set of 25853 objects. Total size = 3320992 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0  11731  45   929072  28    929072  28 str
     1   5832  23   469760  14   1398832  42 tuple
     2    324   1   277728   8   1676560  50 dict (no owner)
     3     70   0   216976   7   1893536  57 dict of module
     4    199   1   210856   6   2104392  63 dict of type
     5   1627   6   208256   6   2312648  70 types.CodeType
     6   1592   6   191040   6   2503688  75 function
     7    199   1   177008   5   2680696  81 type
     8    124   0   135328   4   2816024  85 dict of class
     9   1045   4    83600   3   2899624  87 __builtin__.wrapper_descriptor
<90 more rows. Type e.g. '_.more' to view.>

그리고:

>>> hp.iso(1, [1], "1", (1,), {1:1}, None)
Partition of a set of 6 objects. Total size = 560 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0      1  17      280  50       280  50 dict (no owner)
     1      1  17      136  24       416  74 list
     2      1  17       64  11       480  86 tuple
     3      1  17       40   7       520  93 str
     4      1  17       24   4       544  97 int
     5      1  17       16   3       560 100 types.NoneType

를 사용할 때dir([object])내된기능그, ▁the,▁get▁built다▁can있-니▁you__sizeof__내장된 기능의

>>> a = -1
>>> a.__sizeof__()
24

Python 표준 라이브러리의 모듈을 사용할 수도 있습니다.예를 들어 Pymppler와 달리 C에서 클래스가 구현된 개체에 잘 작동하는 것 같습니다.

언급URL : https://stackoverflow.com/questions/1331471/in-memory-size-of-a-python-structure