initialiser un tableau numpy
Est-il possible d'initialiser un tableau numpy d'une forme et de l'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 en 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 sais sur vstack, concatenate, 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_array devrait avoir la forme (10,4). Comment faire ça?
EDIT:
Je veux ajouter la clarification suivante. Je suis conscient que je peux 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 si je ne le fais pas? Lorsque nous utilisons la fonction .append 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 tableau plus grand à partir de tableaux plus petits, en commençant par un tableau vide.
Retourne un nouveau tableau de forme et de type donnés, rempli de zéros.
ou
Retourne un nouveau tableau de forme et de type donnés, remplis de ceux-ci.
ou
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 beaucoup 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 souhaitée, puis compléter les lignes. Vous pouvez cependant utiliser _numpy.append_ si vous le devez.
La façon dont je le fais habituellement consiste à créer une liste régulière, puis à y ajouter mes éléments, puis à 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 occupe deux fois plus d’espace dans la mémoire lors de la création, mais l’ajout à la liste python est très rapide et la création à l’aide de np.array () également.
Introduit dans numpy 1.8:
Renvoie un nouveau tableau de forme et de type donnés, renseigné avec 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]])
_Tableau analogique pour le 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")
Cela fonctionne également avec les 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 utilisez un réseau de calcul, 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:
big_array = numpy.zeros((10,4))
EDIT: Quel genre de séquence faites-vous? Vous devriez consulter les différentes fonctions numpy qui créent des tableaux, telles que numpy.linspace(start, stop, size) (nombre à égale distance) ou numpy.arange(start, stop, inc). Dans la mesure du possible, ces fonctions rendront les tableaux sensiblement plus rapides que d'effectuer le même travail dans des boucles explicites.
Pour votre premier exemple de tableau,
a = numpy.arange(5)
Pour initialiser big_array, utilisez
big_array = numpy.zeros((10,4))
Cela suppose que vous souhaitiez vous initialiser avec des zéros, ce qui est assez typique, mais il existe de nombreuses autres manières d'initialiser un tableau avec 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 avec append , et lorsque tout est réuni dans la liste, convertissez cette liste en un tableau numpy à l’aide de numpy.array(mylist). La raison en est que les listes sont censées grossir 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.
Chaque fois que vous êtes dans la situation suivante:
a = []
for i in range(5):
a.append(i)
et vous voulez quelque chose de similaire numpy, plusieurs réponses précédentes ont indiqué des façons de le faire, mais comme @katrielalex l'a souligné, ces méthodes ne sont pas efficaces. Pour ce faire, la méthode la plus efficace consiste à créer une longue liste, puis à la remodeler à votre guise après 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
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
sortie:
(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]]
Je suggère de définir la forme en premier. Puis 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.]])
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éaffectez le tableau de résultats entier avec numpy.empty et complétez les lignes au fur et à mesure de l'affectation indexée.
Il est parfaitement sûr de préallouer avec empty au lieu de zeros dans l'exemple que vous avez donné, car vous garantissez que l'ensemble du tableau sera rempli avec les fragments que vous générez.
Peut-être que quelque chose comme cela conviendra à 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.]]