Estoy en mi transición viaje de MATLAB para scipy(+numpy)+matplotlib. Sigo teniendo problemas cuando la aplicación de algunas cosas.
Quiero crear un simple vector de la matriz en tres partes diferentes. En MATLAB me gustaría hacer algo como:

vector=[0.2,1:60,60.8];

Esto se traduce en una matriz unidimensional de 62 posiciones. Estoy tratando de implementar esta usando scipy. Lo más cercano que soy ahora es este:

a=[[0.2],linspace(1,60,60),[60.8]]

Sin embargo, esto crea una lista, no una matriz, y por lo tanto no puedo cambiar a un vector de la matriz. Pero luego, cuando lo hago, me sale un error

a=array([[0.2],linspace(1,60,60),[60.8]])
ValueError: setting an array element with a sequence.

Creo que mi principal obstáculo es que no puedo entender cómo traducir esta sencilla operación en MATLAB:

a=[1:2:20];

a numpy. Sé cómo hacer para acceder a las posiciones de un array, aunque no a la hora de crear una secuencia.
Cualquier ayuda será apreciada,
gracias!

OriginalEl autor lllllll | 2012-05-25

8 Comentarios

  1. 15

    Bien NumPy implementa en MATLAB la matriz de creación de la función, vector, utilizando dos funciones en lugar de uno, ya que implícitamente se especifica un determinado eje sobre el que concatenación debería ocurrir. Estas funciones son:

    • r_ (fila concatenación) y

    • c_ (modo de columna)

    Así, por ejemplo, la NumPy equivalente es:

    >>> import numpy as NP
    
    >>> v = NP.r_[.2, 1:10, 60.8]
    
    >>> print(v)
         [  0.2   1.    2.    3.    4.    5.    6.    7.    8.    9.   60.8]

    La columna sabio contraparte es:

    >>> NP.c_[.2, 1:10, 60.8]

    rebanada notación funciona como se espera [inicio:stop:paso]:

    >>> v = NP.r_[.2, 1:25:7, 60.8]
    
    >>> v
      array([  0.2,   1. ,   8. ,  15. ,  22. ,  60.8])

    Aunque si un número imaginario de utilizar como el tercer argumento, la segmentación de la notación se comporta como linspace:

    >>> v = NP.r_[.2, 1:25:7j, 60.8]
    
    >>> v
      array([  0.2,   1. ,   5. ,   9. ,  13. ,  17. ,  21. ,  25. ,  60.8])


    De lo contrario, se comporta como arange:

    >>> v = NP.r_[.2, 1:25:7, 60.8]
    
    >>> v
      array([  0.2,   1. ,   8. ,  15. ,  22. ,  60.8])
    gracias doug! que es muy fresco, y se trata de dos personajes fuera a ser tan compacto como el matlab. genial!!!
    no hay problema. Si mi respuesta fue útil para usted, por favor califique como «aceptado» por hacer clic en «check mark», visible cuando el ratón sobre la puntuación en la esquina superior izquierda de mi respuesta. (O si otra respuesta fue más útil, obviamente, usted querrá marca que uno en su lugar). Sí, es dos más personajes, pero creo que vale la pena, así que NumPy puede tener una función para cada uno de los dos ejes para concatenar (r_ & c_).
    no sabía que, sí! He aprendido mucho de todos los puestos, todos ellos trabajan como yo quería, pero posiblemente el tuyo es el más cercano a MATLAB. gracias a todos!
    c_ no es un modo de columna contraparte… es una versión corta de una especial r_ llamar.. Tu ejemplo para el c_ llamada no va a funcionar.

    OriginalEl autor doug

  2. 5

    Usted podría intentar algo como:

    a = np.hstack(([0.2],np.linspace(1,60,60),[60.8]))
    cierto! esto también funciona, gracias JoshAdel. También, es linspace la única opción que cada vez que quiero hacer algo como a=[1:2:20] ? Lo que implica que no sé el tamaño final del vector, sólo el paso y el inicio/final de puntos. [bis]
    Sólo encontré a mí mismo gracias a mgilson. La respuesta es el rango(start,stop,paso a paso). genial!!!
    Tenga en cuenta que el python integrado en el rango de la función sólo funciona para valores enteros. Numpy proporciona arange que va a hacer la misma cosa (también con flotadores si quieres) devuelve una matriz, pero la documentación indica que linspace es una mejor opción en la mayoría de los casos ya que (debido a errores de redondeo), los resultados de arange podría no ser exactamente lo que usted espera.
    gracias por la comprensión. Sin embargo, yo normalmente requiere la funcionalidad de la gama/arange más de linspace ( que rara vez se utiliza linspace en MATLAB). Desde que tienden a implementar las matrices saber el tamaño de paso en lugar de la final tamaño del vector. Voy a tomar eso en cuenta!

    OriginalEl autor JoshAdel

  3. 3
    np.concatenate([[.2], linspace(1,60,60), [60.8]])
    maldita sea, de verdad! que funciona, muchas gracias larsmans. También, es linspace la única opción que cada vez que quiero hacer algo como a=[1:2:20] ? Lo que implica que no sé el tamaño final del vector, sólo el paso y el inicio/final de puntos.
    Sólo encontré a mí mismo gracias a mgilson. El answe es el rango(start,stop,paso a paso). genial!!!
    También se podría tratar de np.arange(1,20,2) a pesar de ser cuidadoso, ya que esta operación no está incluido en el último número del rango (por ejemplo, la matriz de([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19]) ). Se me olvida cómo Matlab se encarga de esto y por mucho tiempo he ya la sacaron de mi máquina.
    Es bueno saberlo! gracias. MATLAB a mi conocimiento sigue aumentando/disminuyendo y si el punto final que pasa a ser en la gama como a=[0:2:10], entonces a contiene eso. Sin embargo, si el punto final no está incluido, como en a2=[1:2:10], luego 10 no está incluido en a2.

    OriginalEl autor Fred Foo

  4. 2

    De alguna manera me gusta la idea de la construcción de estos segmentado rangos mencionados. Si los usas mucho, tal vez una pequeña función como

    import numpy as np
    
    def segrange(*args):
        result = []
        for arg in args:
            if hasattr(arg,'__iter__'):
                result.append(range(*arg))
            else:
                result.append([arg])
        return np.concatenate(result)

    que le da

    >>> segrange(1., (2,5), (5,10,2))
    [ 1.  2.  3.  4.  5.  7.  9.]

    sería bueno tener. Aunque, probablemente voy a ir a por la respuesta usando concatenar/hstack.

    eso es un buen pensamiento! Creo que voy a tratar de atenerse a la + operador utilizado en mgilson la respuesta a partir de ahora, ya que es la que me parece más cercana a la de matlab, por lo tanto, menos esfuerzo de recordar. Sin embargo, voy a ver si la ejecución de ese código es más conveniente en algunos casos 🙂
    Me corrija si estoy equivocado, pero creo que isinstance(arg,list) es preferido sobre type(arg) is list. También, se podría acortar ese todo si el bloque a hasattr(arg,'__iter__') (y la captura de todo tipo de otros iterables mientras estás en ello)
    sí, su derecho mgilson. pero doug la respuesta de la crianza de _r reemplaza a todos ^^

    OriginalEl autor pwuertz

  5. 1

    si entiendo el matlab correctamente, usted podría lograr algo como esto mediante:

    a=np.array([0.2]+list(range(1,61))+[60.8])

    Pero probablemente hay una mejor manera…el list(range(1,61)) podría ser sólo range(1,61) si usted está usando python 2.X.

    Esto funciona mediante la creación de 3 listas y, a continuación, la concatenación de ellos mediante el uso de + operador.

    La razón de su original intento no funcionó es porque

    a=[ [0.2], np.linspace(1,60,60), [60.8] ] crea una lista de listas, en otras palabras:

    a[0] == [0.2] #another list (length 1)
    a[1] == np.linspace(1,60,60) #an array (length 60)
    a[2] == [60.8] #another list (length 1)

    La array función espera un iterable que es una secuencia o de una secuencia de secuencias que son de la misma longitud.

    gran mgilson! esa es probablemente la más cercana a la sintaxis de MATLAB. Todavía no es tan compacto como un=[0.2,1:60,60.8] pero fresco. muchas gracias, yo lo veo más claro ahora.
    Creo que usted encontrará que mientras un montón de cosas en numpy son tan concisa como en matlab (y un par de cosas un poco más conciso), hay muy pocas cosas que no son tan concisa — sin Embargo, En general me parece que el código mucho más intuitiva.
    A saber, la flexibilidad adquirida, especialmente en el trazado, que es tan enormemente la pena el ‘menos-la concisión’ de la sintaxis, hasta ahora. 🙂

    OriginalEl autor mgilson

  6. 1

    Echar un vistazo a np.r_. Es básicamente equivalente a lo que todo el mundo se ha sugerido, pero si vienes de matlab, que es un poco más intuitivo (y si vienes de cualquier otro idioma, es un poco contra-intuitivo).

    Como un ejemplo, vector=[0.2,1:60,60.8]; se traduce en:

    vector = np.r_[0.2, 1:61, 60.8]

    OriginalEl autor Joe Kington

  7. 1

    Quiero señalar que para cualquier otro, la gente que va de MATLAB para Numpy que se puede construir un np.r_ matriz con dos puntos y, a continuación, utilizarlo para el índice de

    E. g., si usted tiene en matlab

    arr_ones = ones(10,10)

    O en Numpy

    arr_ones = np.ones([10,10])

    Podría en Matlab tomar sólo las columnas de la 1 a la 5 y 7 como este:

    arr_ones(:,[1:5 7])

    Haciendo lo mismo en Numpy no es (al menos para mí) intuitiva.
    Esto le dará una «sintaxis no válida» error:

    arr_ones[:,[1:5,7]]

    Sin embargo esto funciona:

    inds = np.r[1:5,]
    arr_ones[:,inds]

    Sé que esto no es técnicamente una nueva respuesta, pero el uso de un signo de dos puntos para la construcción de una matriz en el momento de la indización en una matriz que parece tan natural en Matlab, estoy apostando a que una gran cantidad de personas que llegan a esta página quiere saber de esto. (Yo vine aquí en lugar de pedir una nueva pregunta.)

    OriginalEl autor NickleDave

Dejar respuesta

Please enter your comment!
Please enter your name here