initialiser un tableau numpy

Existe-t-il un moyen d'initialiser un tableau numpy d'une forme et d'y ajouter? Je vais expliquer ce dont j'ai besoin avec un exemple de liste. Si je veux créer une liste d'objets générés dans une boucle, je peux faire:

a = []
for i in range(5):
    a.append(i)

Je veux faire quelque chose de similaire avec un tableau numpy. Je connais vstack, concaténer etc. Cependant, il semble que ceux-ci nécessitent deux tableaux numpy comme entrées. Ce dont j'ai besoin c'est:

big_array # Initially empty. This is where I don't know what to specify
for i in range(5):
    array i of shape = (2,4) created.
    add to big_array

Le big_arraydevrait avoir une forme (10,4). Comment faire cela?

ÉDITER:

Je veux ajouter la précision suivante. Je suis conscient que je peux le définir big_array = numpy.zeros((10,4))puis le remplir. Cependant, cela nécessite de spécifier la taille de big_array à l'avance. Je connais la taille dans ce cas, mais que faire si je ne le fais pas? Lorsque nous utilisons la .appendfonction pour étendre la liste en python, nous n'avons pas besoin de connaître sa taille finale à l'avance. Je me demande s'il existe quelque chose de similaire pour créer un plus grand tableau à partir de tableaux plus petits, en commençant par un tableau vide.

numpy.zeros

Renvoie un nouveau tableau de forme et de type donnés, rempli de zéros.

ou

numpy.ones

Renvoie un nouveau tableau de forme et de type donnés, rempli de uns.

ou

numpy.empty

Renvoie un nouveau tableau de forme et de type donnés, sans initialiser les entrées.

Cependant, la mentalité dans laquelle nous construisons un tableau en ajoutant des éléments à une liste n'est pas très utilisée dans numpy, car elle est moins efficace (les types de données numpy sont beaucoup plus proches des tableaux C sous-jacents). Au lieu de cela, vous devez préallouer le tableau à la taille dont vous avez besoin, puis remplir les lignes. Vous pouvez cependant l'utiliser numpy.appendsi vous le devez.

La façon dont je le fais habituellement est de créer une liste régulière, puis d'y ajouter mes éléments, et enfin de transformer la liste en un tableau numpy comme suit:

import numpy as np
big_array = [] #  empty regular list
for i in range(5):
    arr = i*np.ones((2,4)) # for instance
    big_array.append(arr)
big_np_array = np.array(big_array)  # transformed to a numpy array

bien sûr, votre objet final prend deux fois plus d'espace dans la mémoire à l'étape de création, mais l'ajout sur la liste python est très rapide, et la création en utilisant np.array () également.

Introduit dans numpy 1.8:

numpy.full

Renvoie un nouveau tableau de forme et de type donnés, rempli de fill_value.

Exemples:

>>> import numpy as np
>>> np.full((2, 2), np.inf)
array([[ inf,  inf],
       [ inf,  inf]])
>>> np.full((2, 2), 10)
array([[10, 10],
       [10, 10]])

Array analogique pour les python

a = []
for i in range(5):
    a.append(i)

est:

import numpy as np

a = np.empty((0))
for i in range(5):
    a = np.append(a, i)

numpy.fromiter() est ce que vous recherchez:

big_array = numpy.fromiter(xrange(5), dtype="int")

Il fonctionne également avec des expressions de générateur, par exemple:

big_array = numpy.fromiter( (i*(i+1)/2 for i in xrange(5)), dtype="int" )

Si vous connaissez la longueur du tableau à l'avance, vous pouvez le spécifier avec un argument optionnel 'count'.

Vous voulez éviter autant que possible les boucles explicites lorsque vous faites du calcul par matrice, car cela réduit le gain de vitesse de cette forme de calcul. Il existe plusieurs façons d'initialiser un tableau numpy. Si vous voulez qu'il soit rempli de zéros, faites comme katrielalex a dit:

big_array = numpy.zeros((10,4))

EDIT: Quel genre de séquence faites-vous? Vous devriez vérifier les différentes fonctions numpy qui créent des tableaux, comme numpy.linspace(start, stop, size)(nombre également espacé), ou numpy.arange(start, stop, inc). Lorsque cela est possible, ces fonctions rendront les tableaux beaucoup plus rapides que de faire le même travail dans des boucles explicites

Pour votre premier exemple de tableau, utilisez,

a = numpy.arange(5)

Pour initialiser big_array, utilisez

big_array = numpy.zeros((10,4))

Cela suppose que vous souhaitiez initialiser avec des zéros, ce qui est assez typique, mais il existe de nombreuses autres façons d'initialiser un tableau dans numpy .

Edit: Si vous ne connaissez pas la taille de big_array à l'avance, il est généralement préférable de créer d'abord une liste Python en utilisant append, et lorsque vous avez tout rassemblé dans la liste, convertissez cette liste en un tableau numpy en utilisant numpy.array(mylist). La raison en est que les listes sont censées se développer très efficacement et rapidement, alors que numpy.concatenate serait très inefficace car les tableaux numpy ne changent pas facilement de taille. Mais une fois que tout est rassemblé dans une liste et que vous connaissez la taille finale du tableau, un tableau numpy peut être construit efficacement.

Pour initialiser un tableau numpy avec une matrice spécifique:

import numpy as np

mat = np.array([[1, 1, 0, 0, 0],
                [0, 1, 0, 0, 1],
                [1, 0, 0, 1, 1],
                [0, 0, 0, 0, 0],
                [1, 0, 1, 0, 1]])

print mat.shape
print mat

production:

(5, 5)
[[1 1 0 0 0]
 [0 1 0 0 1]
 [1 0 0 1 1]
 [0 0 0 0 0]
 [1 0 1 0 1]]

Chaque fois que vous vous trouvez dans la situation suivante:

a = []
for i in range(5):
    a.append(i)

et vous voulez quelque chose de similaire dans numpy, plusieurs réponses précédentes ont indiqué des moyens de le faire, mais comme @katrielalex l'a souligné, ces méthodes ne sont pas efficaces. Le moyen efficace de le faire est de créer une longue liste, puis de la remodeler comme vous le souhaitez après avoir une longue liste. Par exemple, disons que je lis quelques lignes d'un fichier et que chaque ligne a une liste de nombres et que je veux construire un tableau numpy de forme (nombre de lignes lues, longueur du vecteur dans chaque ligne). Voici comment je le ferais plus efficacement:

long_list = []
counter = 0
with open('filename', 'r') as f:
    for row in f:
        row_list = row.split()
        long_list.extend(row_list)
        counter++
#  now we have a long list and we are ready to reshape
result = np.array(long_list).reshape(counter, len(row_list)) #  desired numpy array

Je me rends compte que c'est un peu tard, mais je n'ai remarqué aucune des autres réponses mentionnant l'indexation dans le tableau vide:

big_array = numpy.empty(10, 4)
for i in range(5):
    array_i = numpy.random.random(2, 4)
    big_array[2 * i:2 * (i + 1), :] = array_i

De cette façon, vous préallouez tout le tableau de résultats avec numpy.emptyet remplissez les lignes au fur et à mesure en utilisant l'affectation indexée.

Il est parfaitement sûr de préallouer avec emptyplutôt que zerosdans l'exemple que vous avez donné puisque vous garantissez que le tableau entier sera rempli avec les morceaux que vous générez.

Je suggérerais d'abord de définir la forme. Ensuite, parcourez-le pour insérer des valeurs.

big_array= np.zeros(shape = ( 6, 2 ))
for it in range(6):
    big_array[it] = (it,it) # For example

>>>big_array

array([[ 0.,  0.],
       [ 1.,  1.],
       [ 2.,  2.],
       [ 3.,  3.],
       [ 4.,  4.],
       [ 5.,  5.]])

Peut-être que quelque chose comme ça répondra à vos besoins.

import numpy as np

N = 5
res = []

for i in range(N):
    res.append(np.cumsum(np.ones(shape=(2,4))))

res = np.array(res).reshape((10, 4))
print(res)

Qui produit la sortie suivante

[[ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]]