Comment puis-je vérifier l'utilisation de la mémoire des objets dans iPython?

Question

J'utilise iPython pour exécuter mon code. Je me demande s'il existe un module ou une commande qui me permettrait de vérifier l'utilisation de la mémoire d'un objet. Par exemple:

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

Quelque chose comme %memusage <object> et retourner la mémoire utilisée par l'objet.

double

Find out how much memory is being used by an object in Python

Answer 1

Malheureusement, ce n'est pas possible, mais il y a plusieurs façons de rapprocher la réponse:

1. pour des objets très simples (par exemple, ints, chaînes, flottants, doubles) qui sont représentés plus ou moins comme de simples types de langage C, vous pouvez simplement calculer le nombre d'octets comme avec John Mulder's solution.

2. Pour les objets plus complexes, une bonne approximation consiste à sérialiser l'objet en une chaîne à l'aide de cPickle.dumps. La longueur de la chaîne est une bonne approximation de la quantité de mémoire requise pour stocker un objet.

Il existe un gros problème avec la solution 2, à savoir que les objets contiennent généralement des références à d'autres objets. Par exemple, un dictionnaire contient des chaînes de caractères et d'autres objets en tant que valeurs. Ces autres objets peuvent être partagés. Puisque pickle essaie toujours de faire une sérialisation complète de l'objet, il surestimera toujours la quantité de mémoire nécessaire pour stocker un objet.

Answer 2

MISE À JOUR: Voici another, recette peut-être plus approfondie pour estimer la taille d'un objet python.

Voici une thread aborder une question similaire

La solution proposée est d'écrire votre propre ... en utilisant des estimations de la taille connue des primitives, les frais généraux d'objets de python, et les tailles de construction dans les types de conteneurs.

Étant donné que le code n'est pas si longtemps, voici une copie directe de celui-ci:

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 

Answer 3

Si vous utilisez un numpy array, vous pouvez utiliser l'attribut ndarray.nbytes pour évaluer sa taille en mémoire:

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

Answer 4

pour la taille totale de la population locale (en Mo):

from sys import getsizeof 
sum([getsizeof(k) for k in locals().keys()])/10**6