Comment Python Numpy économise-t-il de la mémoire par rapport à une liste ?

Question

Je suis tombé sur le morceau de code suivant en étudiant Numpy:

import numpy as np

import time
import sys
S= range(1000)
print(sys.getsizeof(5)*len(S))

D= np.arange(1000)
print(D.size*D.itemsize)

La sortie de ceci est:

O/P -  14000

4000

Ainsi, Numpy économise de l'espace mémoire. Mais je veux savoir comment Numpy le fait-il?

Source: https://www.edureka.co/blog/python-numpy-tutorial/

Modifier: Cette question répond seulement à la moitié de ma question. Ne mentionne rien concernant ce que fait le module Numpy.

Answer 1

Les tableaux NumPy sont plus compacts que les listes Python - une liste de listes comme vous le décrivez, en Python, prendrait au moins 20 Mo ou plus, tandis qu'un tableau 3D NumPy avec des flottants en simple précision dans les cellules tiendrait dans 4 Mo. L'accès à la lecture et à l'écriture des éléments est également plus rapide avec NumPy.

Peut-être que vous ne vous souciez pas tellement pour juste un million de cellules, mais vous le feriez certainement pour un milliard de cellules - aucune des deux approches ne rentrerait dans une architecture 32 bits, mais avec des compilations 64 bits, NumPy s'en tirerait avec environ 4 Go, Python seul aurait besoin d'au moins environ 12 Go (beaucoup de pointeurs qui doublent de taille) - un matériel beaucoup plus coûteux!

La différence est principalement due à "l'indirectness" - une liste Python est un tableau de pointeurs vers des objets Python, au moins 4 octets par pointeur plus 16 octets pour même le plus petit objet Python (4 pour le pointeur de type, 4 pour le compte de référence, 4 pour la valeur - et les allocateurs de mémoire arrondissent à 16). Un tableau NumPy est un tableau de valeurs uniformes - les nombres en simple précision prennent 4 octets chacun, ceux en double précision, 8 octets. Moins flexible, mais vous payez beaucoup pour la flexibilité des listes Python standard!

Answer 2

Dans votre exemple, D.size == len(S), donc la différence est due à la différence entre D.itemsize (8) et sys.getsizeof(5) (28).

D.dtype vous montre que NumPy a utilisé int64 comme type de données, qui utilise (sans surprise) 64 bits == 8 bytes par élément. Il s'agit vraiment uniquement des données numériques brutes, semblables à un type de données en C (sous le capot, c'est à peu près exactement ça).

En revanche, Python utilise un int pour stocker les éléments, qui (comme l'a souligné la question liée par FlyingTeller) est bien plus que simplement les données numériques brutes.

Answer 3

Un ndarray stocke ses données dans un tampon de données contigu

Pour un exemple dans ma session ipython actuelle :

In [63]: x.shape
Out[63]: (35, 7)
In [64]: x.dtype
Out[64]: dtype('int64')
In [65]: x.size
Out[65]: 245
In [66]: x.itemsize
Out[66]: 8
In [67]: x.nbytes
Out[67]: 1960

Le tableau référencé par x a un bloc de mémoire avec des informations telles que shape et strides, et ce tampon de données qui occupe 1960 octets.

Identifier l'utilisation de la mémoire d'une liste, par exemple xl = x.tolist() est plus difficile. len(xl) est de 35, c'est-à-dire que son tampon de données a 35 pointeurs. Mais chaque pointeur référence une liste différente de 7 éléments. Chacune de ces listes a des pointeurs vers des nombres. Dans mon exemple, les nombres sont tous des entiers inférieurs à 255, donc chacun est unique (les répétitions pointent vers le même objet). Pour les entiers et les flottants plus grands, il y aura un objet Python séparé pour chaque. Ainsi, l'empreinte mémoire d'une liste dépend du degré d'imbrication ainsi que du type des éléments individuels.

ndarray peut également avoir un type object, auquel cas il contient également des pointeurs vers des objets ailleurs en mémoire.

Et une autre subtilité - le tampon de pointeurs principal d'une liste est légèrement surdimensionné, pour rendre append plus rapide.