Quelle est la taille maximale d'un tableau numpy?

Un ValueError indique la taille est trop grande pour la répartition, il n'y a pas assez de mémoire. Sur mon portable, en utilisant 64bits python, je peut l'affecter, si je réduis le nombre de bits:

In [16]: a=np.arange(2708000000)
---------------------------------------------------------------------------
MemoryError                               Traceback (most recent call last)
<ipython-input-16-aaa1699e97c5> in <module>()
----> 1 a=np.arange(2708000000)

MemoryError: 

# Note I don't get a ValueError

In [17]: a = np.arange(2708000000, dtype=np.int8)

In [18]: a.nbytes
Out[18]: 2708000000

In [19]: a.nbytes * 1e-6
Out[19]: 2708.0

Dans votre cas, arange utilise int64 bits, ce qui signifie qu'il est 16 fois plus, ou autour de 43 GO. un 32 bits du processus d'accès autour de 4 GO de mémoire.

La raison sous-jacente est la taille des pointeurs pour accéder à des données et combien de nombres vous pouvez représenter avec ces bits:

In [26]: np.iinfo(np.int32)
Out[26]: iinfo(min=-2147483648, max=2147483647, dtype=int32)
In [27]: np.iinfo(np.int64)
Out[27]: iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)

Remarque que je peux reproduire votre ValueError si je tente de créer un univers grand tableau:

In [29]: a = np.arange(1e350)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-29-230a6916f777> in <module>()
----> 1 a = np.arange(1e350)

ValueError: Maximum allowed size exceeded

Si votre machine dispose de beaucoup de mémoire, comme vous l'avez dit, il sera 64 bits, vous devez installer Python 64 bits pour pouvoir y accéder. D'autre part, pour ces grands ensembles de données, vous devriez envisager la possibilité de l'utilisation de base des calculs.

OriginalL'auteur Davidmh

Il est en effet liée à la valeur maximale du système de l'adresse de longueur, pour le dire simplement, système 32 bits ou 64 bits du système. Voici une explication pour ces questions, à l'origine de Mark Dickinson

Réponse courte: le Python objet de frais généraux est de vous tuer. En Python 2.x sur une machine 64 bits, d'une liste de chaînes consomme 48 octets par entrée de liste de même avant de prendre en compte le contenu des chaînes. C'est plus de 8,7 Go de surcharge pour la taille du tableau que vous décrivez. Sur une machine 32 bits ça va être un peu mieux: seulement 28 octets par entrée de la liste.

Une longue explication: vous devez être conscient que Python objets eux-mêmes peuvent être assez volumineux: même des objets simples comme des entiers, des flotteurs et des cordes. Dans votre code, vous êtes de se retrouver avec une liste de listes de chaînes. Sur mon (64-bit) de la machine, même une chaîne vide d'objet prend 40 octets, et que vous avez besoin d'ajouter 8 octets pour la liste de pointeur qui pointe vers cette chaîne de l'objet en mémoire. Donc, c'est déjà 48 octets par entrée, ou environ 8.7 Go. Étant donné que Python alloue de la mémoire, en multiple de 8 octets à la fois, et que vos chaînes sont presque certainement non-vide, vous êtes en fait en regardant 56 ou 64 octets (je ne sais pas combien de temps vos chaînes sont par participation.

Solutions possibles:

(1) que Vous pourriez faire (un peu) mieux par la conversion de vos entrées de chaînes à ints ou de flotteurs appropriées.

(2) Vous feriez beaucoup mieux en utilisant Python de type tableau (pas la même que la liste!) ou par l'utilisation de numpy: votre ints ou les flotteurs ne prendra que 4 ou 8 octets chacun.

Depuis la version 2.6 de Python, vous pouvez obtenir des renseignements de base au sujet de l'objet tailles avec le sys.getsizeof fonction. Notez que si vous l'appliquez à une liste (ou autre récipient) puis le retour de la taille ne prend pas en compte la taille de la liste des objets; seulement de la structure utilisée pour contenir ces objets. Voici quelques valeurs sur ma machine.

OriginalL'auteur KarlFG