arrays - Quels sont les avantages de NumPy régulier sur les listes Python?

676

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

Peut-être que vous ne vous souciez pas tant que ça pour seulement un million de cellules, mais vous avez certainement pour un milliard de cellules -- aucune approche permettrait de s'intégrer dans une architecture 32 bits, mais avec des versions 64 bits NumPy pouvait s'échapper avec 4 GO ou alors, Python seul aurait besoin d'au moins environ 12 GO (beaucoup de pointeurs qui double de volume) -- un beaucoup plus coûteux morceau de matériel!

La différence est principalement due à la "indirectness" -- une liste Python est un tableau de pointeurs vers des objets Python, au moins 4 octets par pointeur de plus de 16 octets, même pour le plus petit objet Python (4 pour le type pointeur, 4 pour le compte de référence, 4 pour la valeur -- et la mémoire allocateurs de tours jusqu'à 16). Un tableau NumPy est un tableau de valeurs uniformes -- nombres simple précision prend 4 octets chacun, double précision, de 8 octets. Moins souple, mais vous payez considérablement la souplesse des standards de Python, les listes de!
- J'ai essayé d'utiliser "sys.getsizeof()" pour comparer la taille de Python, les listes et les tableaux NumPy avec le même nombre d'éléments et il ne semble pas indiquer que les tableaux NumPy étaient beaucoup plus petites. Est-ce le cas ou est-sys.getsizeof() d'avoir des problèmes à comprendre comment grand un tableau NumPy est?
- n'est pas fiable. La documentation stipule clairement que: Seulement la consommation de mémoire attribuée directement à l'objet est pris en compte, pas la consommation de mémoire des objets auxquels il se réfère. Cela signifie que si vous avez imbriqué python, les listes de la taille des éléments n'est pas pris en compte.
- getsizeof sur une liste ne vous raconte pas la quantité de RAM de la liste de l'objet lui-même consomme et la RAM consommée par les pointeurs dans son tableau de données, il n'a pas vous dire combien de RAM est consommée par les objets que ceux des pointeurs de référence.
- pourriez-vous s'il vous plaît laissez-moi savoir où en êtes-vous de ces chiffres?
- Juste un heads-up, votre estimation de la taille de l'équivalent en Python de liste de liste de listes est éteint. Les 4 GO de tableau numpy de C floats (4 octets) serait traduit en quelque chose de plus de 32 GO d'une valeur de lists et Python floats (qui sont en fait C doubles), pas de 12 GO; chaque float sur 64 bits Python occupe ~24 octets (en supposant qu'aucun alignement des pertes dans l'allocateur), plus un autre de 8 octets dans la list pour contenir la référence (et qui ignore la surutilisation et de l'objet en-têtes pour le lists eux-mêmes, qui pourrait ajouter un autre GO, en fonction de combien exactement la surutilisation se produit).
- Vous pourriez obtenir la liste Python de la liste des listes de descendre aussi bas que 8 GO si tous les stockés floats étaient de référence pour le même float, mais compte tenu de Python n'a pas de float la mise en cache, rien d'autre que la même valeur de plus et plus (pas utile), il faudrait vous manuellement mettre en œuvre un stage pour votre floats à réaliser que la mémoire de réduction, et il semble assez peu probable que vous auriez si peu unique floats que le stage serait d'aider (depuis le stagiaire cache lui-même serait la fin de la hausse de la consommation d'une tonne de mémoire par la suite).
InformationsquelleAutor Alex Martelli
220

NumPy n'est pas seulement plus efficace; il est aussi plus pratique. Vous obtenez beaucoup de vecteur et matrice des opérations pour libre, qui permettent parfois d'éviter le travail inutile. Et ils sont aussi efficacement mis en œuvre.

Par exemple, vous pouvez lire votre cube directement à partir d'un fichier dans un tableau:
```
x = numpy.fromfile(file=open("data"), dtype=float).reshape((100, 100, 100))
```
Somme au long de la seconde dimension:
```
s = x.sum(axis=1)
```
Trouver lequel les cellules sont au-dessus d'un seuil:
```
(x > 0.5).nonzero()
```
Supprimer tous les même indexé tranche le long de la troisième dimension:
```
x[:, :, ::2]
```
Aussi, de nombreuses bibliothèques de travailler avec des tableaux NumPy. Par exemple, l'analyse statistique et de visualisation des bibliothèques.

Même si vous n'avez pas de problèmes de performance, l'apprentissage NumPy est la valeur de l'effort.
- Merci - vous avez fourni une autre bonne raison dans votre troisième et dernier exemple, comme l'est d'ailleurs, je vais être à la recherche de la matrice de cellules au-dessus du seuil. Par ailleurs, j'ai le chargement de sqlLite. Le fichier approche sera beaucoup plus efficace.
InformationsquelleAutor Roberto Bonvallet
106

Alex mentionné l'efficacité de mémoire, et Roberto mentionne commodité, et ce sont deux bons points. Pour un peu plus d'idées, je vais vous parler de vitesse et fonctionnalité.

Fonctionnalité: Vous obtenez beaucoup construit en avec NumPy, Fft, circonvolutions, la recherche rapide, les statistiques de base, l'algèbre linéaire, histogrammes, etc. Et vraiment, qui ne peuvent vivre sans Fft?

Vitesse: Voici un test à faire une somme sur une liste et un tableau NumPy, montrant que la somme sur le tableau NumPy est 10x plus rapide (dans ce test -- kilométrage peut varier).
```
from numpy import arange
from timeit import Timer

Nelements = 10000
Ntimeits = 10000

x = arange(Nelements)
y = range(Nelements)

t_numpy = Timer("x.sum()", "from __main__ import x")
t_list = Timer("sum(y)", "from __main__ import y")
print("numpy: %.3e" % (t_numpy.timeit(Ntimeits)/Ntimeits,))
print("list:  %.3e" % (t_list.timeit(Ntimeits)/Ntimeits,))
```
qui sur mes systèmes (alors que je suis en cours d'exécution d'une sauvegarde) donne:
```
numpy: 3.004e-05
list:  5.363e-04
```
InformationsquelleAutor tom10
39

Voici une belle réponse de la FAQ sur le scipy.org site web:

Quels sont les avantages de faire des tableaux NumPy offrent plus (imbriqué) Python listes?

Python listes sont efficaces à des fins générales de conteneurs. Ils soutiennent
(assez) efficace d'insertion, suppression, ajout, et la concaténation,
et Python interprétations de la liste de les rendre facile à construire et à
manipuler. Cependant, ils présentent certaines limites: elles ne prennent pas en charge
“vectorisé” opérations comme elementwise d'addition et de multiplication,
et le fait qu'ils peuvent contenir des objets de types différents veux dire
que Python doit stocker des informations de type pour chaque élément, et doit
exécuter type d'expédition de code lors de l'utilisation de chaque élément. Cette
signifie également que très peu liste des opérations peuvent être réalisées par
efficace C boucles à chaque itération nécessiterait des vérifications de type et d'autres
L'API Python de comptabilité.

InformationsquelleAutor Eliezer
4

Ont tous mis en évidence presque toutes les principales différences entre un tableau numpy et liste python, je vais juste les informer ici:
1. Numpy tableaux ont une taille fixe à la création, à la différence de python listes (qui peut se développer de manière dynamique). Modification de la taille de ndarray permettra de créer un nouveau tableau et de supprimer l'original.
2. Les éléments dans un tableau Numpy doivent tous être du même type de données (on peut avoir de l'hétérogénéité de type de bien, mais qui ne va pas vous permettre d'opérations mathématiques) et va donc être de la même taille en mémoire
3. Tableaux Numpy sont facilitées avancées mathématiques et d'autres types d'opérations sur un grand nombre de données. Généralement, de telles opérations sont exécutées plus efficacement et avec moins de code que ce qui est possible à l'aide de pythons construire des séquences
InformationsquelleAutor Parvez Khan

Vous devez vous connecter pour publier un commentaire.