Array NumPy: un'introduzione [con esempi]

Stai cercando di iniziare con NumPy? Questa guida ti insegnerà le basi degli array NumPy in Python.

Come primo passo, imparerai come funzionano gli array NumPy in modo diverso rispetto agli elenchi Python. Imparerai quindi diversi modi per creare array NumPy ed eseguire operazioni di base su di essi.

Cominciamo!

Nozioni di base sugli array NumPy

NumPy è una delle librerie Python più popolari per il calcolo scientifico e l'analisi dei dati. Le strutture dati di base in NumPy sono matrici N-dimensionali (matrici ND). Hanno capacità di trasmissione e ci consentono di vettorizzare le operazioni per la velocità e utilizzare funzioni matematiche integrate per migliorare le prestazioni.

Per iniziare a lavorare con NumPy, devi prima installare la libreria e importarla nel tuo ambiente di lavoro. È disponibile come pacchetto PyPI installabile tramite pip.

Per installare NumPy, apri il tuo terminale ed esegui il seguente comando:

 pip3 install numpy

Dopo aver installato NumPy, puoi importarlo nel tuo ambiente di lavoro con un alias. Il solito alias è np .

 import numpy as np

Nota : l'importazione di NumPy con l'alias np non è un requisito ma una convenzione consigliata.

Elenchi Python e array NumPy

Considera il seguente elenco di numeri Python:

 py_list = [1,2,3,4]

Puoi ottenere un array NumPy da un elenco esistente chiamando la funzione np.array() con l'elenco come argomento.

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

Per verificare il tipo di np_arr1 , chiami la funzione type() incorporata, vedrai che è ndarray , la struttura dati fondamentale in NumPy.

 type(np_arr1) # numpy.ndarray

Sebbene l'elenco Python e l'array NumPy possano sembrare simili, ci sono alcune differenze:

• Un elenco Python può contenere oggetti di diversi tipi di dati, mentre un array NumPy contiene elementi dello stesso tipo di dati. Il tipo di dati predefinito è float con una precisione di 64 bit (float64).
• Gli elementi di un elenco Python non sono necessariamente archiviati in posizioni contigue nella memoria. Tuttavia, gli elementi di un array NumPy sono archiviati in un blocco contiguo in memoria. Di conseguenza, è più veloce cercare e accedere agli elementi.

Esaminiamo un paio di altre differenze.

Trasmissione

Una potente funzionalità degli array NumPy è la trasmissione. Supponiamo di voler aggiungere 2 a tutti gli elementi di np_arr1 e py_list .

Proviamo ad aggiungere 2 a py_list e vediamo cosa succede:

 >>> py_list + 2

Vediamo che otteniamo un TypeError che afferma che possiamo concatenare solo due elenchi e l'aggiunta di py_list + 2 in questo modo non è supportata.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

Proviamo la stessa operazione sull'array, np_arr1 .

 >>> np_arr1 + 2

Nel risultato, vediamo che 2 è stato aggiunto a ciascun elemento dell'array.

 array([3, 4, 5, 6])

Questo perché NumPy ha trasmesso implicitamente lo scalare 2 a un array di forma compatibile per produrre questo risultato.

Vettorizzazione

Gli array NumPy supportano la vettorizzazione per operazioni più rapide in termini di elementi. Supponiamo di voler trovare la somma in termini di elementi dei due array.

L'uso di una semplice operazione + sulla lista restituirebbe la concatenazione delle due liste (che non è quello che vogliamo!).

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

Ma la stessa operazione sull'array NumPy, np_arr1 , restituisce la somma in termini di elementi di np_arr1 con se stesso.

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

Allo stesso modo, gli elenchi nidificati possono avere un aspetto simile nella struttura a un array NumPy N-dimensionale. Tuttavia, le differenze discusse finora valgono.

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

Come creare array NumPy

Puoi sempre creare array NumPy da elenchi Python esistenti usando np.array(list-obj) . Tuttavia, questo non è il modo più efficiente.

Invece, puoi utilizzare diverse funzioni integrate che ti consentono di creare matrici di una forma specifica. La forma dell'array è una tupla che denota la dimensione dell'array lungo ogni dimensione. Ad esempio, la forma di un array 2×2 con due righe e due colonne è (2,2). In questa sezione impareremo come utilizzare alcune di queste funzioni integrate.

Creazione di matrici di zeri e uno

Spesso è utile creare un array di dimensioni specifiche popolate con tutti zeri o tutti uno. E poi usali e modificali nei passaggi successivi del programma.

Possiamo usare la funzione zeros() per creare un array di zeri. Passa la forma dell'array richiesto come tupla: np.zeros(shape) .

 array0 = np.zeros((3,3)) print(array0)

Ecco l'output, un array 2D di zeri:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

È possibile accedere agli attributi dell'array NumPy, chiamare attributi come dtype e shape , utilizzando la notazione punto, come mostrato di seguito:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

Per ottenere un array di quelli, puoi usare la funzione np.ones() .

 array1 = np.ones((3,3)) print(array1)

 [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]

Creazione di una matrice di identità

La matrice identità è ampiamente utilizzata in diverse applicazioni in algebra lineare. E puoi usare la funzione np.eye() per creare una matrice identità. La funzione np.eye() accetta solo un argomento: l'ordine della matrice ( n ).

 arrayi = np.eye(3) print(arrayi)

 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

Creazione di matrici di numeri casuali

Puoi anche creare matrici di una forma specifica popolate con numeri casuali tratti da distribuzioni specifiche. Le distribuzioni di probabilità comunemente utilizzate sono la distribuzione uniforme e la distribuzione normale standard.

La funzione randn() , che fa parte del modulo random di NumPy, può essere utilizzata per generare array di numeri campionati da una distribuzione normale standard . La distribuzione normale standard è una distribuzione gaussiana con media zero e varianza unitaria.

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() restituisce un array di numeri campione da una distribuzione uniforme nell'intervallo [0,1).

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

Puoi anche creare un array di numeri interi casuali usando la funzione randint() che fa parte del modulo random di NumPy. np.random.randint(low, high, size) restituisce un array di numeri interi. La forma dell'array viene dedotta dall'argomento size e gli interi assumono valori nell'intervallo [low,high) .

Ecco un esempio:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

Altre utili funzioni integrate

Successivamente, esaminiamo alcune altre funzioni utili per creare array NumPy.

La funzione arange() restituisce un array di numeri compreso tra un valore start e uno finale in passi di un valore di step : start , start + step , start + 2*step up to ma stop stop I valori start e step sono facoltativi . La dimensione del passo predefinita è 1 e il valore iniziale predefinito è 0.

In questo esempio, array_a è un array di numeri che inizia da 1 fino a 10 escluso in incrementi di 0,5.

 array_a = np.arange(1,10,0.5) print(array_a)

 [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

Puoi anche creare array di numeri equidistanti usando np.linspace() . Utilizzare np.linspace(start, stop, num) per ottenere un array di num numeri equidistanti tra i valori start e stop .

Qui, arr_lin è un array di 5 numeri equidistanti nell'intervallo [1,10].

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

Allo stesso modo, arr_lin2 è un array di 10 numeri equidistanti nell'intervallo [1,20].

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

A differenza della funzione arange() , la funzione linspace() include l'endpoint per impostazione predefinita.

Operazioni di base sugli array NumPy

Successivamente, esaminiamo alcune delle operazioni di base sugli array NumPy.

Trovare gli elementi minimo e massimo

Ogni volta che usiamo le funzioni del modulo random di NumPy per creare array, otterremo un risultato diverso ogni volta che il codice viene eseguito. Per ottenere risultati riproducibili, dovremmo impostare un seme: np.random.seed(seed_value) .

Nell'esempio seguente, ho impostato il seme per la riproducibilità, int_arr1 è un array di sette numeri interi casuali nell'intervallo [1.100).

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• Per trovare l'elemento massimo nell'array, puoi chiamare il metodo max() sull'oggetto array, int_arr1 e
• Per trovare l'elemento minimo nell'array, puoi chiamare il metodo min() sull'oggetto array, int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

Trovare l'Indice degli Elementi Massimo e Minimo

A volte, potrebbe essere necessario trovare l'indice degli elementi massimo e minimo. Per fare ciò, puoi chiamare i argmax() e argmin() sull'oggetto array.

Qui, l'elemento massimo 73 si verifica all'indice 2.

 int_arr1.argmax() # 2

E l'elemento minimo 20 si verifica all'indice 0.

 int_arr1.argmin() # 0

Puoi anche usare np.argmax(array) e np.argmin(array) per trovare rispettivamente gli indici degli elementi massimo e minimo. Ulteriori informazioni sulla funzione NumPy argmax() .

Come concatenare gli array NumPy

Un'altra operazione comune che potresti voler eseguire con gli array NumPy è la concatenazione.

Concatenazione verticale tramite vstack

Puoi concatenare gli array verticalmente usando la funzione vstack() .

Ecco un esempio. arr1 è un array di uno con due righe e tre colonne e arr2 è un array di zeri due righe e tre colonne.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Possiamo concatenare questi due array verticalmente usando la funzione vstack() come mostrato:

 np.vstack((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Poiché l'impilamento avviene verticalmente, i due array dovrebbero avere lo stesso numero di colonne .

Cambiamo arr2 in modo che abbia la forma (2,2). Ora ha due righe e due colonne.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

Pertanto, la concatenazione verticale non è possibile e otteniamo un ValueError.

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

Concatenazione orizzontale tramite hstack

Puoi concatenare gli array NumPy orizzontalmente usando la funzione hstack() , come mostrato di seguito.

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

Poiché l'impilamento avviene orizzontalmente, gli array di input devono avere lo stesso numero di righe . Qui, sia arr1 che arr2 hanno tre righe.

 array([[1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.]])

Usando concatenare

È inoltre possibile utilizzare gli array NumPy concatenati lungo un asse specifico utilizzando la funzione concatenate() . Imposta l'argomento facoltativo axis sull'asse lungo il quale desideri concatenare; il valore di default dell'asse è zero.

Ecco alcuni esempi:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Quando non specifichiamo l'asse lungo il quale concatenare, gli array vengono concatenati lungo l'asse 0. Nell'array risultante, il secondo array arr2 viene aggiunto (come righe) sotto il primo array.

 np.concatenate((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Quando specifichiamo axis = 1 , otteniamo il seguente risultato. arr2 è concatenato (come colonne) accanto al primo array, arr1 .

 np.concatenate((arr1,arr2),axis=1)

 array([[1., 1., 1., 0., 0., 0.], [1., 1., 1., 0., 0., 0.]])

Come con le hstack() e vstack() , le dimensioni degli array lungo l'asse di concatenazione devono corrispondere .

Conclusione

In questo tutorial, hai appreso le differenze tra gli array NumPy e gli elenchi Python, con particolare attenzione ai vantaggi degli array N-dimensionali in termini di velocità ed efficienza.

Hai anche imparato diverse funzioni utili per creare array di una particolare dimensione ed eseguire operazioni comuni, come trovare gli elementi minimo e massimo, concatenare array e altro ancora.

Successivamente, scopri come rimodellare gli array NumPy.