2012-07-09 21 views
9

In MATLAB e Numpy, gli array possono essere indicizzati dagli array. Tuttavia, il comportamento è diverso. Lasciatemi spiegare questo con un esempio.Indicizzazione array simile a MATLAB con Numpy

MATLAB:

>> A = rand(5,5) 

A = 

    0.1622 0.6020 0.4505 0.8258 0.1067 
    0.7943 0.2630 0.0838 0.5383 0.9619 
    0.3112 0.6541 0.2290 0.9961 0.0046 
    0.5285 0.6892 0.9133 0.0782 0.7749 
    0.1656 0.7482 0.1524 0.4427 0.8173 

>> A([1,3,5],[1,3,5]) 

ans = 

    0.1622 0.4505 0.1067 
    0.3112 0.2290 0.0046 
    0.1656 0.1524 0.8173 

Numpy:

In [2]: A = arange(25).reshape((5,5)) 

In [3]: A 
Out[3]: 
array([[ 0, 1, 2, 3, 4], 
     [ 5, 6, 7, 8, 9], 
     [10, 11, 12, 13, 14], 
     [15, 16, 17, 18, 19], 
     [20, 21, 22, 23, 24]]) 

In [6]: A[[0,2,4], [0,2,4]] 
Out[6]: array([ 0, 12, 24]) 

In parole: MATLAB seleziona righe e colonne, NumPy "cerniere" i due array di indice e utilizza le tuple per puntare a voci.

Come posso ottenere il comportamento di MATLAB con Numpy?

risposta

7

Si può fare questo:

A[[0,2,4],:][:,[0,2,4]] 

che darà il risultato MATLAB-come si desidera.

Vale la pena di essere consapevole del fatto che, piuttosto incoerente, se si utilizza fette per l'indicizzazione, allora si ottengono risultati MATLAB-like senza tali aggiustamenti:

>>> A[1:3,1:3] 
array([[ 6, 7], 
     [11,12]]) 

In NumPy, a differenza di MATLAB, 1:3 non è solo una sigla per [1,2] o qualcosa del genere. (A quel punto mi sento in dovere di dire qualcosa sicuramente saprete già, e cioè che Python 1:3 è un po 'come [1,2] mentre MATLAB di è un po' come [1,2,3]:. Il punto finale destro è incluso in MATLAB ed escluso in Python)

+3

Questo è in realtà abbastanza inefficiente. Richiede la creazione di una matrice temporanea in memoria che può essere abbastanza grande a seconda delle dimensioni degli array con cui si sta lavorando. Esistono diversi modi più efficienti per farlo, incluso l'utilizzo della funzione helper ix_. –

+2

Sì, tutto corretto. D'altra parte, la cosa costruita da 'ix_' è anche piuttosto grande, anche se temporanea. Ho fatto alcuni esperimenti di temporizzazione per un array 5x5 come nella domanda originale, con i seguenti risultati. '[,:] [:,]' è circa il 25% più veloce di '[ix _()]', ma se stai usando gli stessi indici ogni volta poi costruisci un array di indicizzazione * una volta * con 'ix_' e riutilizzalo è circa 10 volte più veloce, anche se ovviamente si paga un costo nell'utilizzo della memoria. –

+2

np.ix_, nella maggior parte dei casi, utilizza solo una quantità insignificante di memoria perché restituisce le visualizzazioni dei suoi argomenti. Anche np.ix_ è un'operazione a tempo costante mentre A [I1,:] [:, I2] è ~ n^2 sia in termini di tempo che di utilizzo della memoria. Ma se hai davvero bisogno di un incremento delle prestazioni del 25% sul tuo array 5x5, devi fare quello che devi fare. –

14

È può utilizzare la funzione di supporto numpy.ix_ per ottenere il comportamento Matlab:

from numpy import ix_ 
A[ ix_([0,2,4], [0,2,4]) ] 
1

il modo efficace per farlo con NumPy sta per rimodellare la matrice indice corrispondenti assi sono indicizzazione cioè

In [103]: a=numpy.arange(100).reshape(10,10) 

In [104]: a 
Out[104]: 
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 
    [10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 
    [20, 21, 22, 23, 24, 25, 26, 27, 28, 29], 
    [30, 31, 32, 33, 34, 35, 36, 37, 38, 39], 
    [40, 41, 42, 43, 44, 45, 46, 47, 48, 49], 
    [50, 51, 52, 53, 54, 55, 56, 57, 58, 59], 
    [60, 61, 62, 63, 64, 65, 66, 67, 68, 69], 
    [70, 71, 72, 73, 74, 75, 76, 77, 78, 79], 
    [80, 81, 82, 83, 84, 85, 86, 87, 88, 89], 
    [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]]) 

In [105]: x=numpy.array([3,6,9]) 

In [106]: y=numpy.array([2,7,8]) 

In [107]: a[x[:,numpy.newaxis],y[numpy.newaxis,:]] 
Out[107]: 
array([[32, 37, 38], 
     [62, 67, 68], 
     [92, 97, 98]]) 

regole di NumPy di ​​trasmissioni sono tuo amico (e molto meglio di Matlab) ...

HTH

Problemi correlati