In memoria dimensioni di una struttura pitone
https://stackoverflow.com/questions/1331471
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
C'è un punto di riferimento per la dimensione della memoria di Python dati struttura su piattaforme a 32 e 64 bit?
In caso contrario, questo sarebbe bello avere sul SO. Il più esauriente e meglio! Quindi, quanti byte sono utilizzati dalle seguenti strutture Python (a seconda della len e il tipo di contenuto se del caso)?
-
int -
float - di riferimento
-
str - stringa unicode
-
tuple -
list -
dict -
set -
array.array -
numpy.array -
deque - classi di nuovo stile di oggetto
- classi vecchio-stile di oggetto
- ... e tutto ciò che sto dimenticando!
(Per i contenitori che mantengono solo i riferimenti ad altri oggetti, che ovviamente non vogliamo contare la dimensione della voce se stessi, dal momento che potrebbe essere condiviso.)
Inoltre, c'è un modo per ottenere la memoria utilizzata da un oggetto in fase di esecuzione (ricorsivamente o no)?
Soluzione
La raccomandazione da una precedente interrogazione su questo è stato quello di utilizzare sys.getsizeof () , citando :
>>> import sys
>>> x = 2
>>> sys.getsizeof(x)
14
>>> sys.getsizeof(sys.getsizeof)
32
>>> sys.getsizeof('this')
38
>>> sys.getsizeof('this also')
48
Si potrebbe prendere questo approccio:
>>> 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 a 32 bit):
decimal 36
dict 136
float 16
int 12
list 32
object 8
set 112
str 22
tuple 24
unicode 32
Python 3.3 (Linux a 32 bit)
decimal 52
dict 144
float 16
int 14
list 32
object 8
set 112
str 26
tuple 24
unicode 26
2016/8/1
OSX, Python 2.7.10 (di default, 23 Ottobre 2015, 19:19:21) [GCC 4.2.1 compatibile LLVM di Apple 7.0.0 (clang-700.0.59.5)] su Darwin
decimal 80
dict 280
float 24
int 24
list 72
object 16
set 232
str 38
tuple 56
unicode 52
Altri suggerimenti
Sono stato felicemente usando pympler per questi compiti. È compatibile con molte versioni di Python - il modulo asizeof, in particolare, risale al 2.2
Ad esempio, utilizzando l'esempio di hughdbrown ma con from pympler import asizeof all'inizio e print asizeof.asizeof(v) alla fine, vedo (sistema di Python 2.5 su 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
Chiaramente v'è una certa approssimazione qui, ma ho trovato molto utile per l'analisi footprint e messa a punto.
Queste risposte tutti raccolgono informazioni sulle dimensioni poco profonda. Ho il sospetto che i visitatori di questa domanda finirà qui in cerca di rispondere alla domanda: "Quanto è grande questo oggetto complesso in memoria?"
C'è una grande risposta qui: https://goshippo.com / blog / misura-real-size-qualsiasi-python-oggetto /
La battuta finale:
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
Utilizzato in questo modo:
In [1]: get_size(1)
Out[1]: 24
In [2]: get_size([1])
Out[2]: 104
In [3]: get_size([[1]])
Out[3]: 184
Se vuoi sapere modello di memoria di Python più a fondo, c'è un grande articolo qui che ha un simile "dimensione totale" frammento di codice come parte di una spiegazione più: https://code.tutsplus.com/tutorials/understand-how-much-memory -Le-python-oggetti-uso - CMS-25609
Prova di memoria profiler. profiler
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
Inoltre è possibile utilizzare guppy modulo.
>>> 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.>
E
>>> 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
Quando si utilizza il dir ([oggetto]) funzione built-in, è possibile il sizeof la funzione built-in.
>>> a = -1
>>> a.__sizeof__()
24
