Ajouter un échec à un tableau vide de NumPy
je suis en train de remplir un vide(pas de np.vide!) tableau avec des valeurs en utilisant l'ajout mais je reçois erreur:
mon code est le suivant:
import numpy as np
result=np.asarray([np.asarray([]),np.asarray([])])
result[0]=np.append([result[0]],[1,2])
Et j'obtiens:
ValueError: could not broadcast input array from shape (2) into shape (0)
6 réponses
numpy.append est assez différent de celui de la liste.ajouter en python. Je sais que ça a bouleversé quelques programmeurs novices à num PY. numpy.append est plus concaténer, il fait un nouveau tableau et le remplit avec les valeurs de l'ancien tableau et la nouvelle valeur(s) d'être ajoutée. Par exemple:
import numpy
old = numpy.array([1, 2, 3, 4])
new = numpy.append(old, 5)
print old
# [1, 2, 3, 4]
print new
# [1, 2, 3, 4, 5]
new = numpy.append(new, [6, 7])
print new
# [1, 2, 3, 4, 5, 6, 7]
je pense que vous pourriez atteindre votre objectif en faisant quelque chose comme:
result = numpy.zeros((10,))
result[0:2] = [1, 2]
# Or
result = numpy.zeros((10, 2))
result[0, :] = [1, 2]
mise à jour:
Si vous avez besoin de créer un tableau numpy en utilisant la boucle, et vous ne savez pas à l'avance quelle sera la taille finale du tableau, vous pouvez faire quelque chose comme:
import numpy as np
a = np.array([0., 1.])
b = np.array([2., 3.])
temp = []
while True:
rnd = random.randint(0, 100)
if rnd > 50:
temp.append(a)
else:
temp.append(b)
if rnd == 0:
break
result = np.array(temp)
dans mon exemple, le résultat sera un tableau (N, 2), Où N est le nombre de fois que la boucle est lancée, mais évidemment vous pouvez l'ajuster à vos besoins.
nouvelle mise à jour
L'erreur que vous voyez n'a rien à voir avec les types de, il a à voir avec la forme des tableaux numpy vous essayez concaténer. Si vous faites np.append(a, b) les formes de a et b doivent correspondre. Si vous ajoutez un (2, n) et un (n,) Vous obtiendrez un tableau (3, n). Votre code essaie d'ajouter a (1, 0) à a (2,). Ces formes ne correspondent pas donc vous obtenez une erreur.
je pourrais comprendre la question incorrectement, mais si vous voulez déclarer un tableau d'une certaine forme mais sans rien à l'intérieur, le suivant pourrait être utile:
Initialise le tableau vide:
>>> a = np.array([]).reshape(0,3)
>>> a
array([], shape=(0, 3), dtype=float64)
Maintenant, vous pouvez utiliser ce tableau pour ajouter des lignes de forme similaire. Rappelez-vous qu'un tableau nummpy est immuable, donc un nouveau tableau est créé pour chaque itération:
>>> for i in range(3):
... a = np.vstack([a, [i,i,i]])
...
>>> a
array([[ 0., 0., 0.],
[ 1., 1., 1.],
[ 2., 2., 2.]])
np.vstack et np.hstack est la méthode la plus courante pour combiner les tableaux numpy, mais venant de Matlab je préfère np.r_ et np.c_:
Concaténate 1d:
>>> a = np.array([])
>>> for i in range(3):
... a = np.r_[a, [i, i, i]]
...
>>> a
array([ 0., 0., 0., 1., 1., 1., 2., 2., 2.])
lignes concaténées:
>>> a = np.array([]).reshape(0,3)
>>> for i in range(3):
... a = np.r_[a, [[i,i,i]]]
...
>>> a
array([[ 0., 0., 0.],
[ 1., 1., 1.],
[ 2., 2., 2.]])
colonnes concaténées:
>>> a = np.array([]).reshape(3,0)
>>> for i in range(3):
... a = np.c_[a, [[i],[i],[i]]]
...
>>> a
array([[ 0., 1., 2.],
[ 0., 1., 2.],
[ 0., 1., 2.]])
Cette erreur provient du fait que vous tentez de définir un objet de la forme (0,) comme un objet de forme (2,). Si vous ajoutez ce que vous voulez sans le forcer à être égal au résultat[0] Il n'y a pas de problème:
b = np.append([result[0]], [1,2])
mais quand vous définissez résultat[0] = b vous égalisez des objets de formes différentes, et vous ne pouvez pas faire cela. Qu'essayez-vous de faire?
voici le résultat de l'exécution de votre code dans Ipython. Notez que result est un (2,0) array, 2 rangées, 0 colonnes, 0 éléments. Le append produit un tableau (2,) . result[0] est "1519100920 tableau. Votre message d'erreur doit avoir à voir avec le fait d'essayer d'assigner ce tableau de 2 éléments dans une fente de taille 0. Puisque result est dtype=float64 , seuls des scalaires peuvent être assignés à ses éléments.
In [65]: result=np.asarray([np.asarray([]),np.asarray([])])
In [66]: result
Out[66]: array([], shape=(2, 0), dtype=float64)
In [67]: result[0]
Out[67]: array([], dtype=float64)
In [68]: np.append(result[0],[1,2])
Out[68]: array([ 1., 2.])
np.array n'est pas une liste Python. Tous les éléments d'un tableau sont du même type (comme indiqué par le dtype ). Notez également que result n'est pas un tableau de tableaux.
résultat aurait aussi pu être construit comme
ll = [[],[]]
result = np.array(ll)
tandis que
ll[0] = [1,2]
# ll = [[1,2],[]]
il n'en est pas de même pour le résultat.
np.zeros((2,0)) produit également votre result .
en fait il y a une autre excentricité à result .
result[0] = 1
ne modifie pas les valeurs de result . Il accepte la cession, mais puisqu'il a 0 colonnes, il n'y a pas de place pour mettre le 1 . Cette affectation fonctionnerait en Résultat a été créé comme np.zeros((2,1)) . Mais encore ne peut pas accepter une liste.
mais si result a 2 colonnes, alors vous pouvez assigner une liste de 2 éléments à l'une de ses lignes.
result = np.zeros((2,2))
result[0] # == [0,0]
result[0] = [1,2]
Que voulez-vous précisément result pour ressembler à après l'opération append ?
numpy.append copie toujours le tableau avant d'ajouter les nouvelles valeurs. Votre code est l'équivalent du suivant:
import numpy as np
result = np.zeros((2,0))
new_result = np.append([result[0]],[1,2])
result[0] = new_result # ERROR: has shape (2,0), new_result has shape (2,)
vous voulez peut-être faire ça?
import numpy as np
result = np.zeros((2,0))
result = np.append([result[0]],[1,2])
fil ' Multiplier deux matrices élément sage, où l'un des tableaux a des tableaux comme des éléments ' a un exemple de construction d'un tableau de tableaux. Si les subarrays sont de la même taille, num PY fait un tableau 2d. Mais s'ils diffèrent en longueur, il fait un tableau avec dtype=object , et les subarrays conservent leur identité.
après cela, vous pourriez faire quelque chose comme ceci:
In [5]: result=np.array([np.zeros((1)),np.zeros((2))])
In [6]: result
Out[6]: array([array([ 0.]), array([ 0., 0.])], dtype=object)
In [7]: np.append([result[0]],[1,2])
Out[7]: array([ 0., 1., 2.])
In [8]: result[0]
Out[8]: array([ 0.])
In [9]: result[0]=np.append([result[0]],[1,2])
In [10]: result
Out[10]: array([array([ 0., 1., 2.]), array([ 0., 0.])], dtype=object)
cependant, je ne voyez immédiatement les avantages que cela présente par rapport à une liste ou des listes Python pures. Il ne fonctionne pas comme un tableau 2d. Par exemple , je dois utiliser result[0][1] , pas result[0,1] . Si les subarrays ont tous la même longueur, je dois utiliser np.array(result.tolist()) pour produire un tableau 2d.