array numpy che crea con una sequenza

Question

Sono sul mio viaggio di transizione da MATLAB a scipy (+ numpy) + matplotlib. Continuo ad avere problemi nell'implementare alcune cose. Voglio creare una semplice matrice vettoriale in tre parti differenti. In MATLAB vorrei fare qualcosa di simile:

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

Questo si traduce in una matrice monodimensionale di 62 posizioni. Sto cercando di implementarlo usando scipy. Il più vicino mi trovo ora è questo:

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

Tuttavia, questo crea un elenco, non un array, e quindi non posso rimodellare a un array di vettore. Ma poi, quando faccio questo, ottengo un errore

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

Credo che la mia principale ostacolo è che io non riesco a capire come tradurre questa semplice operazione in MATLAB:

a=[1:2:20]; 

a numpy . So come farlo per accedere alle posizioni in un array, anche se non quando si crea una sequenza. Qualsiasi aiuto sarà apprezzato, grazie!

Answer 1

Well NumPy implementa la funzione di MATLAB array creazione, vettore, utilizzando due funzioni invece di uno - ogni specifica implicitamente un asse particolare lungo il quale concatenazione dovrebbe verificarsi. Queste funzioni sono:

• r_ (concatenazione row-saggio) e

• c_ (colonna-saggio)

Così, per il tuo esempio , l'equivalente NumPy è:

>>> 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 controparte colonna-saggio è:

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

fetta notazione funziona come previsto [partenza: fermata: passo]:

>>> v = NP.r_[.2, 1:25:7, 60.8] 

>>> v 
    array([ 0.2, 1. , 8. , 15. , 22. , 60.8]) 

Anche se un numero immaginario di usato come terzo argomento, la notazione di slicing si comporta come linspace:

>>> v = NP.r_[.2, 1:25:7j, 60.8] 

>>> v 
    array([ 0.2, 1. , 5. , 9. , 13. , 17. , 21. , 25. , 60.8]) 

In caso contrario, si comporta come arange:

>>> v = NP.r_[.2, 1:25:7, 60.8] 

>>> v 
    array([ 0.2, 1. , 8. , 15. , 22. , 60.8]) 

Answer 2

Si potrebbe provare qualcosa di simile:

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

Answer 3

se ho capito bene il MATLAB, si potrebbe realizzare qualcosa di simile utilizzando:

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

Ma c'è probabilmente un modo migliore ... il list(range(1,61)) potrebbe essere solo range(1,61) se stai usando python 2.X.

Questo funziona creando 3 elenchi e quindi concatenandoli utilizzando l'operatore +.

Il motivo per il vostro originale tentativo non ha funzionato è perché

a=[ [0.2], np.linspace(1,60,60), [60.8] ] crea una lista di liste - in altre parole:

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 funzione array prevede un iterabile che è una sequenza, o una sequenza di sequenze della stessa lunghezza.

Answer 4

np.concatenate([[.2], linspace(1,60,60), [60.8]]) 

Answer 5

arange(0.2,60.8,0.2) fa quello che vuoi?

http://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html

Answer 6

ho un po 'come l'idea di costruire questi intervalli segmentati che hai menzionato. Se li usate molto, forse una piccola funzione come

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) 

che ti dà

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

sarebbe bello avere. Anche se probabilmente dovrei cercare la risposta usando concatenate/hstack.

Answer 7

Dai un'occhiata allo np.r_.È fondamentalmente equivalente a quello che tutti gli altri hanno suggerito, ma se provieni da matlab, è un po 'più intuitivo (e se provieni da qualsiasi altra lingua, è un po' contro-intuitivo).

Come esempio, vector=[0.2,1:60,60.8]; traduce:

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

Answer 8

Voglio solo sottolineare per tutte le altre persone che vanno da MATLAB per Numpy che è possibile costruire un array np.r_ con i due punti e quindi utilizzarlo per indicizzare

Ad esempio, se si dispone in MATLAB

arr_ones = ones(10,10) 

O in Numpy

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

Si potrebbe in Matlab prende solo le colonne da 1 a 5 e 7 in questo modo:

arr_ones(:,[1:5 7]) 

fare lo stesso in Numpy non è (almeno per me) intuitivo. Questo vi darà un errore di "sintassi non valida":

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

Tuttavia questo funziona:

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

So che questo non è tecnicamente una nuova risposta, ma usando i due punti per costruire una matrice per l'indicizzazione in una matrice sembra così naturale in Matlab, sto scommettendo che molte persone che vengono in questa pagina vorranno sapere questo. (Sono venuto qui invece di fare una nuova domanda.)