Allocation mémoire listes python

[CendreWapiti]

Bonjour,
Alors voilà, mettons que j'ai un ensemble de 50 objets de type grosmachin, et que je les range dans une liste L python (et pas un array numpy) de longueur 1000, c'est à dire dans laquelle 50 cases contiennent des objets de type grosmachin et 950 contiennent le nombre 0.

Le truc c'est que la taille en mémoire d'un gros machin est très importante.
Ma question porte sur la taille mémoire de la liste ainsi créée :
Est ce que taille(L) = 50*taille(grosmachin) + 950*taille(0) ou alors taille(L) = 1000*taille(grosmachin)?

Autre question : qu'est-ce qui prend le plus de place en mémoire : un objet de type None, un booléen, ou l'entier 0 ?

[tinkymento]

Je te laisse tester avec la commande :

Code : Tout sélectionner

liste.__sizeof__()

[CendreWapiti]

Je te laisse tester avec la commande :

Code : Tout sélectionner

liste.__sizeof__()

Et bien merci beaucoup, la réponse est donc :
None < True < 0
et :
taille(L) = 1000*taille(grosmachin)

[np*]

Bonjour,

Il vaut mieux utiliser sys.getsizeof qui prend également en compte les coûts additionnels dus au ramasse-miette (ça ne change rien ici).

Chez moi (avec Python 3.5.1)

Code : Tout sélectionner

sys.getsizeof(None) == 16
sys.getsizeof(True) == sys.getsizeof(1) == 28

mais

Code : Tout sélectionner

sys.getsizeof(False) == 24 

Rigolo non ?

On peut regarder comment ça se passe en mémoire :

Code : Tout sélectionner

In [1]: import sys, ctypes

In [2]: bytearray((ctypes.c_ubyte * sys.getsizeof(False)).from_address(id(False)))
Out[2]: bytearray(b'\xda\x04\x00\x00\x00\x00\x00\x00`\xe7\xe0\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

In [3]: bytearray((ctypes.c_ubyte * sys.getsizeof(True)).from_address(id(True)))
Out[3]: bytearray(b'\x96\x05\x00\x00\x00\x00\x00\x00`\xe7\xe0\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00')

Par contre ce que vous dites sur les listes me surprend. À ma connaissance les listes stockent plutôt des pointeurs vers les objets, et je m'attendrais à ce qu'une liste d'une taille donnée ait toujours à peu près la même taille en mémoire (pas exactement à cause du redimensionnement dynamique). Et c'est bien ce que je trouve en faisant diverses expérimentations par exemple:

Code : Tout sélectionner

In [1]: import sys

In [2]: sys.getsizeof(0)
Out[2]: 24

In [3]: sys.getsizeof(set(range(100)))
Out[3]: 8416

In [4]: sys.getsizeof([0 for _ in range(1000)])
Out[4]: 9024

In [5]: sys.getsizeof([set(range(100)) for _ in range(1000)])
Out[5]: 9024

Comment avez-vous trouvé :

Code : Tout sélectionner

taille(L) = 1000*taille(grosmachin)

[np*]

un objet de type None

C'est juste pour pinailler

None n'est pas un type, c'est un objet de type NoneType

[fakbill]

une liste en python c'est un array et non pas une liste chainée.
https://wiki.python.org/moin/TimeComplexity
donc les overheads en mémoire sont presque nuls.

un objet de type None, un booléen, ou l'entier 0 ?

Etrange question. Python n'est pas un langage bas niveau donc ce genre de question...

Au fait, "gros" c'est quoi pour toi?

[CendreWapiti]

Comment avez-vous trouvé :

Code : Tout sélectionner

taille(L) = 1000*taille(grosmachin)

C'est une erreur de ma part, si j'avais conduit une vraie expérience, j'aurais conclu que la taille de la liste en mémoire ne dépendait pas de ce qu'il y avait dedans, mais uniquement de sa longueur (enfin je crois )

Au fait, "gros" c'est quoi pour toi?

Quand je dis "grosmachin", je parle d'un objet qui a plus de 50 attributs et une dizaine de méthodes