En mémoire la taille d'une structure de python
https://stackoverflow.com/questions/1331471
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Y at-il une référence pour la taille de la mémoire de stucture de données Python sur les plates-formes 32 bits et 64 bits?
Dans le cas contraire, ce serait agréable d'avoir sur SO. Plus exhaustif mieux! Alors combien d'octets sont utilisés par les structures Python suivantes (en fonction du len et le type de contenu le cas échéant)?
-
int -
float - référence
-
str - string unicode
-
tuple -
list -
dict -
set -
array.array -
numpy.array -
deque - Classes nouveau style objet
- les classes de style ancien objet
- ... et tout ce que j'oublie!
(pour les conteneurs qui ne garder que des références à d'autres objets, nous ne voulons évidemment pas compter la taille de l'élément eux-mêmes, car il pourrait être partagée.)
En outre, il est un moyen d'obtenir la mémoire utilisée par un objet à l'exécution (récursive ou non)?
La solution
La recommandation de une question précédente sur ce point était d'utiliser sys.getsizeof () , 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 utiliser 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
2,7 python (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
01/08/2016
OSX, Python 2.7.10 (par défaut 23 Oct 2015, 19:19:21) [GCC 4.2.1 compatibles Apple LLVM 7.0.0 (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
Autres conseils
J'ai heureusement utilise 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 à la fin print asizeof.asizeof(v), 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 est clair qu'il ya une approximation, mais je l'ai trouvé très utile pour l'analyse de l'empreinte et le réglage.
Ces réponses toutes recueillir des informations de taille peu profonde. Je soupçonne que les visiteurs de cette question finir par ici pour répondre à la question suivante: « Quelle est la taille de cet objet complexe dans la mémoire? »
Il y a une grande réponse ici: https://goshippo.com / blog / mesure-real taille-any-python-objet /
La 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 ceci:
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 voulez connaître le modèle de mémoire de Python plus profondément, il y a un grand article ici qui a un même extrait « taille totale » du Code dans le cadre d'une explication plus: https://code.tutsplus.com/tutorials/understand-how-much-memory -Vos-python-objets-utilisation - CMS-25609
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
Vous pouvez également 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.>
>>> 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
Lorsque vous utilisez le répertoire ([object]) fonction intégrée, vous pouvez sizeof fonction intégrée.
>>> a = -1
>>> a.__sizeof__()
24
