Anexado sin éxito a una matriz NumPy vacía

Estoy tratando de llenar una matriz vacía (¡no np.empty!) Con valores usando el apéndice pero obtengo el error:

Mi código es el siguiente:

import numpy as np result=np.asarray([np.asarray([]),np.asarray([])]) result[0]=np.append([result[0]],[1,2]) 

Y estoy recibiendo:

 ValueError: could not broadcast input array from shape (2) into shape (0) 

    numpy.append es bastante diferente de list.append en python. Sé que eso ha sido arrojado a algunos progtwigdores nuevos para numpy. numpy.append se numpy.append más a concatenar, numpy.append una nueva matriz y la llena con los valores de la matriz anterior y los nuevos valores que se agregarán. Por ejemplo:

     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] 

    Creo que podrías lograr tu objective haciendo algo como:

     result = numpy.zeros((10,)) result[0:2] = [1, 2] # Or result = numpy.zeros((10, 2)) result[0, :] = [1, 2] 

    Actualizar:

    Si necesita crear una matriz numpy usando un bucle, y no sabe de antemano cuál será el tamaño final de la matriz, puede hacer algo como:

     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) 

    En mi ejemplo, el resultado será una matriz (N, 2), donde N es el número de veces que se ejecutó el bucle, pero obviamente puede ajustarlo a sus necesidades.

    nueva actualización

    El error que está viendo no tiene nada que ver con los tipos, tiene que ver con la forma de las matrices numpy que está tratando de concatenar. Si lo hace np.append(a, b) las formas de a y b deben coincidir. Si agrega una (2, n) y (n,) obtendrá una matriz (3, n). Su código está intentando agregar un (1, 0) a un (2,). Esas formas no coinciden, así que obtienes un error.

    Puede que entienda la pregunta de manera incorrecta, pero si desea declarar una matriz de cierta forma pero sin nada dentro, lo siguiente podría ser útil:

    Inicializar matriz vacía:

     >>> a = np.array([]).reshape(0,3) >>> a array([], shape=(0, 3), dtype=float64) 

    Ahora puede usar esta matriz para añadir filas de forma similar a la misma. Recuerde que una matriz numpy es inmutable, por lo que se crea una nueva matriz para cada iteración:

     >>> 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 y np.hstack es el método más común para combinar matrices numpy, pero desde Matlab prefiero np.r_ y np.c_:

    Concatenar 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.]) 

    Filas concatenadas:

     >>> 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.]]) 

    Columnas concatenadas:

     >>> 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.]]) 

    Este error surge del hecho de que está intentando definir un objeto de forma (0,) como un objeto de forma (2,). Si agrega lo que desea sin forzar que sea igual al resultado [0], no hay ningún problema:

     b = np.append([result[0]], [1,2]) 

    Pero cuando define el resultado [0] = b, está equiparando objetos de diferentes formas, y no puede hacer esto. ¿Que estás tratando de hacer?

    Aquí está el resultado de ejecutar su código en Ipython. Tenga en cuenta que el result es una matriz (2,0) , 2 filas, 0 columnas, 0 elementos. El append produce una matriz (2,) . result[0] es (0,) matriz. Su mensaje de error tiene que ver con tratar de asignar esa matriz de 2 elementos en una ranura de tamaño 0. Como el result es dtype=float64 , solo los escalares pueden asignarse a sus elementos.

     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 no es una lista de Python. Todos los elementos de una matriz son del mismo tipo (según lo especificado por el tipo de dtype ). Tenga en cuenta también que el result no es una matriz de matrices.

    El resultado también podría haber sido construido como

     ll = [[],[]] result = np.array(ll) 

    mientras

     ll[0] = [1,2] # ll = [[1,2],[]] 

    Lo mismo no es cierto para el resultado.

    np.zeros((2,0)) también produce su result .

    En realidad hay otra peculiaridad que result .

     result[0] = 1 

    No cambia los valores de result . Acepta la asignación, pero como tiene 0 columnas, no hay lugar para colocar el 1 . Esta asignación funcionaría en el resultado se creó como np.zeros((2,1)) . Pero eso todavía no puede aceptar una lista.

    Pero si el result tiene 2 columnas, entonces puede asignar una lista de 2 elementos a una de sus filas.

     result = np.zeros((2,2)) result[0] # == [0,0] result[0] = [1,2] 

    ¿Cuál es exactamente el result que desea que se vea después de la operación de append ?

    numpy.append siempre copia la matriz antes de agregar los nuevos valores. Su código es equivalente a lo siguiente:

     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,) 

    Tal vez te refieres a hacer esto?

     import numpy as np result = np.zeros((2,0)) result = np.append([result[0]],[1,2]) 

    El subproceso SO ‘ Multiplica dos conjuntos de elementos de forma inteligente, donde uno de los conjuntos tiene conjuntos como elementos ‘ tiene un ejemplo de cómo construir un conjunto a partir de conjuntos. Si los subarrays son del mismo tamaño, numpy crea una matriz 2d. Pero si difieren en longitud, hace que una matriz con dtype=object , y las subarrays conserven su identidad.

    Después de eso, podrías hacer algo como esto:

     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) 

    Sin embargo, no veo de antemano qué ventajas tiene esto sobre una lista o listas puras de Python. No funciona como una matriz 2d. Por ejemplo, tengo que usar el result[0][1] , no el result[0,1] . Si los subarrays son todos de la misma longitud, tengo que usar np.array(result.tolist()) para producir una matriz 2D.