web-dev-qa-db-fra.com

Taille en mémoire d'une structure Python

Existe-t-il une référence pour la taille de la mémoire de la structure de données Python sur les plates-formes 32 et 64 bits?

Sinon, ce serait bien de l'avoir sur SO. Le plus exhaustif le mieux! Combien d’octets sont utilisés par les structures Python suivantes (en fonction de la variable len et du type de contenu, le cas échéant)?

  • int
  • float
  • référence
  • str
  • chaîne unicode
  • Tuple
  • list
  • dict
  • set
  • array.array
  • numpy.array
  • deque
  • objet de classes de style nouveau
  • objet de classes de style ancien
  • ... et tout ce que j'oublie!

(Pour les conteneurs ne conservant que des références à d'autres objets, nous ne souhaitons évidemment pas compter la taille de l'élément eux-mêmes, car il pourrait être partagé.)

De plus, existe-t-il un moyen d’utiliser la mémoire utilisée par un objet au moment de l’exécution (de manière récursive ou non)?

pythonmemorymemory-footprint
102
LeMiz

La recommandation de une question précédente à ce sujet était d'utiliser sys.getsizeof () , en citant:

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

Vous pouvez adopter cette approche:

>>> 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 (linux, 32 bits):

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

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 (par défaut, 23 octobre 2015, 19:19:21) [Compatible avec LLVM 7.0.0 compatible Apple (GCC 4.2.1) (clang-700.0.59.5)] sur darwin

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

J'ai utilisé avec plaisir pympler pour de telles tâches. Il est compatible avec de nombreuses versions de Python - le module asizeof en particulier remonte à 2.2!

Par exemple, en utilisant l'exemple de hughdbrown mais avec from pympler import asizeof au début et print asizeof.asizeof(v) à la fin, je vois (système Python 2.5 sur MacOSX 10.5):

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

Il existe clairement une approximation, mais je l’ai trouvée très utile pour l’analyse et le réglage de l’empreinte.

33
Alex Martelli

Ces réponses collectent toutes des informations de taille superficielle. Je suppose que les visiteurs de cette question finiront ici par chercher à répondre à la question suivante: "Quelle est la taille de cet objet complexe dans la mémoire?"

Il y a une excellente réponse ici: https://goshippo.com/blog/measure-real-size-any-python-object/

Le punchline:

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

Utilisé comme tel:

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

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

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

Si vous souhaitez connaître plus en détail le modèle de mémoire de Python, voici un excellent article qui contient un extrait de code "taille totale" similaire dans le cadre d'une explication plus longue: https://code.tutsplus.com/tutorials/understand- combien-de-mémoire-vos-objets-python-use - cms-25609

22
Kobold

Aussi, vous pouvez utiliser guppy module.

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

Et:

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

Essayez le profileur de mémoire . le profileur de mémoire

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

Lorsque vous utilisez la fonction intégrée dir ([objet]), vous pouvez utiliser la fonction sizeof /.

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