Creare gli array di NumPy su Python

Il bello di NumPy è che ti permette di lavorare con numeri, matrici e vettori in modo super efficiente, molto più rapido rispetto alle classiche liste di Python.

Cos'è un array in NumPy? Un array NumPy è fondamentalmente una struttura dati che può contenere una collezione di elementi (come numeri, ma anche stringhe volendo), disposti in righe e colonne, esattamente come in una matrice matematica. La differenza rispetto alle liste di Python è che NumPy è ottimizzato per gestire grandi quantità di dati numerici in maniera molto efficiente.

Ora ti mostro come si può creare un array.

Ricorda prima di tutto, è necessario installare il pacchetto NumPy se non lo hai già. E poi, dentro il codice Python, bisogna importarlo.

import numpy as np

Una volta importata, puoi creare sia array mondodimensionali (es. vettori) che multidimensionali (es. matrici, tensori, ecc.).

Creazione di un array NumPy

Immagina di voler creare un semplice array che contiene i numeri da 1 a 5.

Con NumPy puoi farlo in modo davvero intuitivo tramite il metodo array()

arr = np.array([1, 2, 3, 4, 5])
print(arr)

Ricorda di indicare gli elementi dell'array tra due parentesi quadre, separandoli tra loro con una virgola.

Ed ecco il risultato:

[1 2 3 4 5]

Tutto qui! Hai appena creato un array di una dimensione detto anche "array monodimensionale" o "vettore".

La differenza rispetto alle liste Python è che un array NumPy è molto più veloce quando devi fare operazioni matematiche su grandi quantità di dati.

Array bidimensionali: le matrici

Se vuoi passare a una struttura più interessante, come una matrice (cioè un array bidimensionale), NumPy te lo rende semplice:

matrix = np.array([ [1, 2, 3] , [4, 5, 6] , [7, 8, 9] ])
print(matrix)

In questo caso devi indicare anche ogni riga della matrice tra parentesi quadre, oltre a quelle più esterne che racchiudono tutta la matrice.

Questo crea una matrice 3x3:

[[1 2 3]
[4 5 6]
[7 8 9]]

Vedi com'è ordinata? Ogni lista all'interno della lista principale rappresenta una riga. E con questa matrice puoi fare operazioni matematiche in un attimo, molto più velocemente di come lo faresti con le liste tradizionali di Python.

Gli array multidimensionali

Un array multidimensionale è una struttura dati che serve per organizzare numeri in più di una dimensione.

In parole semplici, è come una lista di liste, o una tabella (matrice), o addirittura una raccolta di tabelle impilate una sopra l’altra.

Ecco un esempio di array a 3 dimensioni, è composto da tre matrici ciascuna con 3 righe e 5 colonne.

Questo tipo di struttura è fondamentale quando si lavora con dati complessi, come immagini, serie temporali, dati scientifici o semplicemente tabelle numeriche.

La libreria NumPy è lo strumento principale per lavorare con array multidimensionali. Vediamo insieme cosa sono e come si usano, con alcuni esempi pratici.

Array monodimensionale (1D)

Un array monodimensionale è la forma più semplice: una singola sequenza di numeri, come una lista.

import numpy as np
np.random.seed(0)
x1 = np.random.randint(10, size=6)

Questo codice genera 6 numeri interi a caso tra 0 e 9.

L’istruzione np.random.seed(0) serve per fissare il punto di partenza della generazione casuale, in modo che ogni volta che esegui il codice, i numeri generati siano sempre gli stessi.

L’istruzione np.random.randint(10, size=6) genera `6` numeri interi casuali compresi tra 0 e 9, creando così un array monodimensionale con sei elementi.

Ecco il risultato finale che viene assegnato alla variabile x1

array([5, 0, 3, 3, 7, 9])

Immagina questa struttura dati come i voti presi da uno studente in 6 test diversi. Tutti su una riga, uno dopo l’altro.

Array Bidimensionale (2D)

Un array bidimensionale è una tabella, fatta di righe e colonne. È come una pagina Excel.

x2 = np.random.randint(10, size=(3, 4))

Questo codice genera una matrice con 3 righe e 4 colonne, riempita con numeri casuali da 0 a 9.

Ecco un possibile risultato che si ottiene:

array([[3, 5, 2, 4],
          [7, 6, 8, 8],
          [1, 6, 7, 7]])

Puoi interpretare questa struttura dati come una tabella in cui ogni riga rappresenta uno studente, e ogni colonna una materia.

In questo caso, potrebbe essere una pagella completa di 3 studenti e 4 materie ciascuno.

Array Tridimensionale (3D)

Quando i dati diventano ancora più ricchi, puoi usare un array tridimensionale. In questo caso, abbiamo più tabelle “impilate”.

x3 = np.random.randint(10, size=(3, 4, 5))

Cosa fa questa istruzione? Crea 3 tabelle, ognuna con 4 righe e 5 colonne.

Ecco un risultato possibile

array([[[8, 8, 1, 6, 7],
[7, 8, 1, 5, 9],
[8, 9, 4, 3, 0],
[3, 5, 0, 2, 3]],

[[8, 1, 3, 3, 3],
[7, 0, 1, 9, 9],
[0, 4, 7, 3, 2],
[7, 2, 0, 0, 4]],

[[5, 5, 6, 8, 4],
[1, 4, 9, 8, 1],
[1, 7, 9, 9, 3],
[6, 7, 2, 0, 3]]])

Come interpretare questa struttura? Immagina di raccogliere 5 misure diverse (es. temperatura, umidità, pressione, vento, luminosità) in 4 momenti della giornata (mattina, mezzogiorno, pomeriggio, sera), per 3 giorni consecutivi.

• Ogni blocco rappresenta un giorno.
• Ogni riga rappresenta un momento della giornata.
• Ogni colonna rappresenta una delle 5 variabili misurate.

E come avere più fogli di lavoro in un unico file Excel con la stessa struttura.

Perché gli array multidimensionali sono utili?

Gli array multidimensionali ti permettono di organizzare i dati in modo ordinato, così da poterli analizzare facilmente.

Che tu stia lavorando con immagini (che sono matrici 2D o 3D), video, dati scientifici o solo tabelle numeriche, imparare a usarli ti apre la porta a tantissime applicazioni pratiche.

Esistono array oltre la terza dimensione? Si, esistono anche se è difficile visualizzarli. Con NumPy puoi creare anche array a 4, 5, 6 o più dimensioni. Questi array rappresentano strutture dati complesse come sequenze temporali di immagini, simulazioni scientifiche o database multi-livello. Sono particolarmente utili quando devi organizzare grandi quantità di dati in modo ordinato e accessibile. Ad esempio, un array a 4 dimensioni è come un cassetto che contiene più array tridimensionali, ognuno dei quali, a sua volta, contiene tabelle bidimensionali. Possiamo descriverlo così.

Operazioni sugli array

Ecco dove NumPy diventa divertente. Immagina di voler sommare ogni elemento di un array a un altro array dello stesso tipo. Con NumPy, è semplicissimo.

Supponiamo di avere questi due array:

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

Per sommarli, basta fare:

somma = arr1 + arr2
print(somma)

Ed ecco il risultato:

[5 7 9]

Dal punto di vista algebrico Python ha sommato gli elementi dei due vettori che si trovano nella stessa posizione

$$ (1,2,3) + (4,5,6) = (1+4, 2+5, 3+6) = (5,7,9) $$

Lo stesso vale per tutte le operazioni matematiche: moltiplicazione, divisione, sottrazione, elevamento a potenza.

Ad esempio, prova a moltiplicare tra loro i due array.

moltiplicazione = arr1 * arr2
print(moltiplicazione)

[ 4 10 18]

Nota come l'operazione avviene elemento per elemento, ovvero moltiplica il primo elemento di `arr1` col primo elemento di `arr2`, e così via.

$$ (1,2,3) \cdot (4,5,6) = (1 \cdot 4, 2 \cdot  5, 3 \cdot  6) = (4,10,18) $$

Ma che succede con le matrici?

Nel caso delle matrici hai due tipi di moltiplicazione a disposizione.

Ad esempio, definisci due matrici 2x2 nelle variabili 'matrix1' e 'matrix2'

matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])

In algebra lineare la moltiplicazione tra due matrice si svolge facendo il prodotto riga per colonna.

Per farlo devi usare il metodo dot().

prodotto = np.dot(matrix1, matrix2)
print(prodotto)

[[19 22]
[43 50]]

Qui, la funzione np.dot esegue il prodotto riga per colonna tra matrici, come si fa in algebra lineare.

$$ \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} \cdot \begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix} = \begin{pmatrix} 1 \cdot 5 + 2 \cdot 7 & 1 \cdot 6 + 2 \cdot 8 \\ 3 \cdot 5 + 4 \cdot 7 & 3 \cdot 6 + 4 \cdot 8 \end{pmatrix} =  \begin{pmatrix} 19 & 22 \\ 43 & 50 \end{pmatrix} $$

Se invece volessi fare una moltiplicazione elemento per elemento (chiamata anche "Hadamard product"), puoi usare il semplice operatore `*`:

hadamard = matrix1 * matrix2
print(hadamard)

[[ 5 12]
[21 32]]

In questo caso la moltiplicazione avviene tra gli elementi che si trovano nella stessa posizione nelle due matrici.

$$ \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} \cdot \begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix} = \begin{pmatrix} 1 \cdot 5 & 2 \cdot 6 \\ 3 \cdot 7 & 4 \cdot 8 \end{pmatrix} = \begin{pmatrix} 5 & 12  \\ 21 & 32 \end{pmatrix} $$

Ecco, vedi quanto è potente NumPy? Puoi fare operazioni matematiche su array e matrici in modo semplice, efficiente e leggibile. E pensa che abbiamo appena toccato la superficie! Ci sono tante altre cose che puoi fare, come calcolare autovalori, invertire matrici, risolvere sistemi di equazioni... insomma, NumPy è uno strumento indispensabile per lavorare nell'algebra lineare con Python.