Come posso controllare l'utilizzo della memoria di oggetti in ipython?

Question

Sto usando ipython per eseguire il mio codice. Mi chiedo se non v'è alcun modulo o un comando che mi permettesse di controllare l'utilizzo della memoria di un oggetto. Per esempio:

In [1]: a = range(10000)
In [2]: %memusage a
Out[2]: 1MB

Qualcosa di simile %memusage <object> e restituire la memoria utilizzata dall'oggetto.

Duplica

  

Scopri come quantità di memoria utilizzata da un oggetto in Python

Answer 1

Purtroppo questo non è possibile, ma ci sono un certo numero di modi per approssimare la risposta:

1. per oggetti molto semplici (ad esempio interi, stringhe, galleggianti, doppie), che sono rappresentate più o meno come semplici tipi C-lingua si può semplicemente calcolare il numero di byte come con John Mulder.

2. Per gli oggetti più complesso una buona approssimazione è per serializzare l'oggetto in una stringa utilizzando cPickle.dumps. La lunghezza della stringa è una buona approssimazione della quantità di memoria necessaria per memorizzare un oggetto.

C'è un grande intoppo con la soluzione 2, vale a dire che gli oggetti di solito contengono riferimenti ad altri oggetti. Ad esempio un dict contiene stringa-chiavi e altri oggetti come valori. Quegli altri oggetti potrebbero essere condivisi. Dal momento che salamoia cerca sempre di fare una serializzazione completa dell'oggetto sarà sempre sovrastimare la quantità di memoria necessaria per memorizzare un oggetto.

Answer 2

Se si utilizza un NumPy serie , allora si può utilizzare il ndarray.nbytes attributo per valutare la sua dimensione in memoria:

from pylab import *   
d = array([2,3,4,5])   
d.nbytes
#Output: 32

Answer 3

UPDATE: Ecco un'altra , ricetta forse più approfondita per stimare le dimensioni di un pitone oggetto.

Ecco un affrontare una domanda simile

La soluzione proposta è quella di scrivere il proprio ... utilizzando alcune stime delle dimensioni noto di primitive, strutture aeree di pitone, e le dimensioni di costruito in tipi di contenitori.

Dal momento che il codice non è così a lungo, qui è una copia diretta di esso:

def sizeof(obj):
    """APPROXIMATE memory taken by some Python objects in 
    the current 32-bit CPython implementation.

    Excludes the space used by items in containers; does not
    take into account overhead of memory allocation from the
    operating system, or over-allocation by lists and dicts.
    """
    T = type(obj)
    if T is int:
        kind = "fixed"
        container = False
        size = 4
    elif T is list or T is tuple:
        kind = "variable"
        container = True
        size = 4*len(obj)
    elif T is dict:
        kind = "variable"
        container = True
        size = 144
        if len(obj) > 8:
            size += 12*(len(obj)-8)
    elif T is str:
        kind = "variable"
        container = False
        size = len(obj) + 1
    else:
        raise TypeError("don't know about this kind of object")
    if kind == "fixed":
        overhead = 8
    else: # "variable"
        overhead = 12
    if container:
        garbage_collector = 8
    else:
        garbage_collector = 0
    malloc = 8 # in most cases
    size = size + overhead + garbage_collector + malloc
    # Round to nearest multiple of 8 bytes
    x = size % 8
    if x != 0:
        size += 8-x
        size = (size + 8)
    return size