Corso
Introduzione a NumPy
4 ore
62.5K
NumPy è, proprio come SciPy, Scikit-Learn, pandas e pacchetti simili. Sono i pacchetti Python che non puoi proprio perdere quando stai imparando la data science, principalmente perché questa libreria ti fornisce una struttura dati per array che offre alcuni vantaggi rispetto alle liste Python, come essere più compatta, avere accesso in lettura e scrittura più veloce, essere più comoda e più efficiente.
Questo tutorial su NumPy si concentrerà proprio su questo. Non solo ti mostrerà cosa sono effettivamente gli array NumPy e come puoi installare Python, ma imparerai anche a creare array (anche quando i tuoi dati provengono da file), come funziona il broadcasting, come chiedere aiuto, come manipolare i tuoi array e come visualizzarli.
Se vuoi sapere ancora di più sugli array NumPy e sulle altre strutture dati di cui avrai bisogno nel tuo percorso di data science, considera di dare un'occhiata al Intro to Python for Data Science di DataCamp, che include un capitolo su NumPy.
Che cos'è un array NumPy in Python?
Hai già letto nell'introduzione che gli array NumPy sono un po' come le liste Python, ma allo stesso tempo molto diversi. Per chi è nuovo all'argomento, chiarifichiamo esattamente cos'è e a cosa serve.
Come suggerisce il nome, un array NumPy è una struttura dati centrale della libreria numpy. Il nome della libreria è l'abbreviazione di “Numeric Python” o “Numerical Python”.
In altre parole, NumPy è una libreria Python che è la libreria principale per il calcolo scientifico in Python. Contiene una raccolta di strumenti e tecniche che possono essere utilizzati per risolvere modelli matematici di problemi in scienza e ingegneria.
Uno di questi strumenti è un oggetto array multidimensionale ad alte prestazioni che è una potente struttura dati per il calcolo efficiente di array e matrici. Per lavorare con questi array, c'è una grande quantità di funzioni matematiche di alto livello che operano su queste matrici e array.
Ma cos'è un array?
Quando guardi la stampa di un paio di array, potresti vederlo come una griglia che contiene valori dello stesso tipo:
import numpy as np
# Define a 1D array
my_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 2D array
my_2d_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 3D array
my_3d_array = np.array([[[1, 2, 3, 4],
[5, 6, 7, 8]],
[[1, 2, 3, 4],
[9, 10, 11, 12]]],
dtype=np.int64)
# Print the 1D array
print("Printing my_array:")
print(my_array)
# Print the 2D array
print("Printing my_2d_array:")
print(my_2d_array)
# Print the 3D array
print("Printing my_3d_array:")
print(my_3d_array)Vedi che, nell'esempio sopra, i dati sono interi. L'array contiene e rappresenta qualsiasi dato regolare in modo strutturato.
Tuttavia, dovresti sapere che, a livello strutturale, un array è fondamentalmente nient'altro che puntatori. È una combinazione di un indirizzo di memoria, un tipo di dato, una forma e degli stride:
- Il data pointer indica l'indirizzo di memoria del primo byte nell'array.
- Il data type o puntatore dtype descrive il tipo di elementi contenuti nell'array.
- La shape indica la forma dell'array.
- Gli stride sono il numero di byte da saltare in memoria per andare all'elemento successivo. Se i tuoi stride sono (10,1), devi avanzare di un byte per arrivare alla colonna successiva e di 10 byte per individuare la riga successiva.
In altre parole, un array contiene informazioni sui dati grezzi, su come localizzare un elemento e su come interpretarlo.
Basta teoria. Vediamolo in pratica:
Puoi testarlo facilmente esplorando gli attributi degli array numpy:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print out memory address
print(my_2d_array.data)
# Print out the shape of `my_array`
print(my_2d_array.shape)
# Print out the data type of `my_array`
print(my_2d_array.dtype)
# Print out the stride of `my_array`
print(my_2d_array.strides)Vedi che ora ottieni molte più informazioni: ad esempio, il tipo di dato stampato è “int64” o tipo intero con segno a 32 bit; Questo è molto più dettagliato! Ciò significa anche che l'array è memorizzato in memoria come 64 byte (dato che ogni intero occupa 8 byte e hai un array di 8 interi). Gli stride dell'array ci dicono che devi saltare 8 byte (un valore) per passare alla colonna successiva, ma 32 byte (4 valori) per arrivare alla stessa posizione nella riga successiva. Pertanto, gli stride per l'array saranno (32,8).
Nota che se imposti il tipo di dato a int32, la tupla degli stride che ottieni sarà (16, 4), poiché dovrai comunque spostarti di un valore alla colonna successiva e di 4 valori per arrivare alla stessa posizione. L'unica cosa che cambia è che ogni intero occuperà 4 byte invece di 8
L'array che vedi sopra è, come già suggerisce il nome, un array bidimensionale: hai righe e colonne. Le righe sono indicate come “asse 0”, mentre le colonne sono “asse 1”. Il numero dell'asse aumenta in base al numero di dimensioni: negli array 3-D, di cui hai visto un esempio nel precedente blocco di codice, avrai un “asse 2” aggiuntivo. Nota che questi assi sono validi solo per array che hanno almeno 2 dimensioni, poiché non ha senso averli per gli array 1-D;
Questi assi torneranno utili più avanti quando manipolerai la forma dei tuoi array NumPy.
Come installare NumPy
Prima di poter iniziare a provare questi array NumPy in prima persona, devi prima assicurarti di averlo installato in locale (supponendo che tu stia lavorando sul tuo pc). Se hai già disponibile la libreria Python, puoi saltare questa sezione :)
Se devi ancora configurare il tuo ambiente, devi sapere che ci sono due modi principali per installare NumPy sul tuo pc: con l'aiuto dei Python wheel o della distribuzione Anaconda di Python.
Installazione con Python Wheels
Per prima cosa assicurati di aver installato Python. Puoi consultare la nostra guida su come installare Python se devi ancora farlo :)
Se stai lavorando su Windows, assicurati di aver aggiunto Python alla variabile di ambiente PATH. Poi, non dimenticare di installare un gestore di pacchetti, come pip, che ti garantirà di poter usare le librerie open source di Python.
Nota che le versioni recenti di Python 3 includono pip, quindi verifica se ce l'hai e, in caso affermativo, aggiornalo prima di installare NumPy:
pip install pip --upgrade
pip --versionUna volta scaricato il file wheel di NumPy, vai nella cartella in cui è stato salvato usando il prompt dei comandi o il terminale.
Installa NumPy usando il seguente comando, sostituendo "numpy-<version>-<architecture>.whl" con il nome del file wheel di NumPy che hai scaricato:
pip install numpy-<version>-<architecture>.whlAd esempio, se hai scaricato NumPy versione 1.20.3 per un sistema Windows a 64 bit, il comando sarà:
pip install numpy-1.20.3-cp39-cp39-win_amd64.whlDopo che l'installazione è completata, puoi verificare che NumPy sia installato aprendo un interprete Python ed eseguendo il seguente comando:
import numpySe non compaiono messaggi di errore, NumPy è installato e pronto all'uso!
Installazione con la distribuzione Anaconda di Python
Per ottenere NumPy, puoi anche scaricare la distribuzione Anaconda di Python. È semplice e ti permetterà di iniziare rapidamente! Se non l'hai già scaricata, vai alla pagina ufficiale per ottenerla. Segui le istruzioni per l'installazione e sei pronto per iniziare!
Ti chiedi perché questo potrebbe essere più facile?
Il vantaggio di ottenere questa distribuzione di Python è che non devi preoccuparti troppo di installare separatamente NumPy o qualsiasi altro pacchetto principale che userai per le tue analisi dei dati, come pandas, scikit-learn, ecc.
Perché, soprattutto se sei molto nuovo a Python, alla programmazione o ai terminali, può essere davvero un sollievo che Anaconda includa già 100 dei pacchetti più popolari per Python, R e Scala per la data science. Ma anche per data scientist più esperti, Anaconda è la soluzione se vuoi iniziare rapidamente ad affrontare problemi di data science.
Inoltre, Anaconda include anche diversi ambienti di sviluppo open source, come Jupyter e Spyder. Se dopo questo tutorial vuoi iniziare a lavorare con Jupyter Notebook, vai al nostro tutorial su Jupyter Notebook.
In breve, considera di scaricare Anaconda per iniziare a lavorare con numpy e altri pacchetti rilevanti per la data science!
Come creare array NumPy
Ora che hai configurato il tuo ambiente, è il momento del lavoro vero. A dire il vero, hai già provato qualcosa con gli array nel codice sopra. Tuttavia, non hai ancora fatto pratica reale con essi perché prima dovevi installare NumPy sul tuo PC. Ora che l'hai fatto, è il momento di vedere cosa devi fare per eseguire i blocchi di codice sopra in autonomia.
Per creare un array numpy, puoi semplicemente usare la funzione np.array(). Tutto ciò che devi fare è passarle una lista e, opzionalmente, puoi anche specificare il tipo di dato. Se vuoi saperne di più sui tipi di dati possibili che puoi scegliere, vai a questa guida o dai un'occhiata veloce al cheat sheet di NumPy di DataCamp.
Non c'è bisogno di memorizzare questi tipi di dati NumPy se sei un nuovo utente, ma devi sapere e curarti dei dati con cui stai lavorando. I tipi di dati sono lì quando hai bisogno di maggiore controllo su come i tuoi dati sono memorizzati in memoria e su disco. Soprattutto nei casi in cui lavori con dati estesi, è bene sapere come controllare il tipo di archiviazione.
Non dimenticare che, per lavorare con la funzione np.array(), devi assicurarti che la libreria numpy sia presente nel tuo ambiente.
La libreria NumPy segue una convenzione di import: quando importi questa libreria, devi assicurarti di importarla come np. Facendo così, ti assicurerai che altri Pythonisti capiscano più facilmente il tuo codice.
Nell'esempio seguente, creerai l'array my_array con cui hai già giocato sopra:
import numpy as np
# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_array`
print(my_array)Se vuoi saperne di più su come creare liste, consulta il nostro tutorial sulle liste in Python.
Tuttavia, a volte non sai quali dati vuoi mettere nel tuo array, oppure vuoi importare dati in un array numpy da un'altra fonte. In questi casi, userai dei segnaposto iniziali o funzioni per caricare dati da testo in array, rispettivamente.
Le sezioni seguenti ti mostreranno come farlo.
Come creare un array NumPy “vuoto”
Quando le persone dicono che stanno creando array “vuoti” spesso intendono che vogliono usare segnaposto iniziali, che potrai riempire in seguito. Puoi inizializzare array con uni o zeri, ma puoi anche creare array riempiti con valori equidistanti, valori costanti o casuali.
Tuttavia, puoi comunque creare anche un array totalmente vuoto.
Per fortuna, ci sono parecchie funzioni per farlo.
Provale tutte qui sotto!
import numpy as np
# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()
# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()
# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()
# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()
# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()
# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()
# Create an array of evenly-spaced values
np.linspace(0,2,9)Consiglio: gioca con le funzioni sopra per capire come funzionano!
- Per alcune, come np.ones(), np.random.random(), np.empty(), np.full() o np.zeros(), l'unica cosa che devi fare per creare array con uni o zeri è passare la shape dell'array che vuoi creare. Come opzione per np.ones() e np.zeros(), puoi anche specificare il tipo di dato. Nel caso di np.full(), devi anche specificare il valore costante che vuoi inserire nell'array.
- Con np.linspace() e np.arange() puoi creare array di valori equidistanti. La differenza tra queste due funzioni è che l'ultimo valore dei tre passati nel blocco di codice sopra indica o il passo per np.linspace() o un numero di campioni per np.arange(). Nel primo caso vuoi, ad esempio, un array di 9 valori compresi tra 0 e 2. Nel secondo, specifichi che vuoi un array che parta da 10 e, a passi di 5, generi valori per l'array che stai creando.
Ricorda che NumPy ti permette anche di creare una matrice identità con np.eye() e np.identity(). Una matrice identità è una matrice quadrata in cui tutti gli elementi sulla diagonale principale sono uni e tutti gli altri sono zeri. Quando moltiplichi una matrice per una matrice identità, la matrice data rimane invariata.
In altre parole, se moltiplichi una matrice per una matrice identità, il prodotto risultante sarà di nuovo la stessa matrice secondo le convenzioni standard della moltiplicazione di matrici.
Anche se il focus di questo tutorial non è dimostrare come funzionano le matrici identità, basta dire che sono utili quando inizi a fare calcoli matriciali: possono semplificare equazioni matematiche, rendendo i tuoi calcoli più efficienti e robusti.
Come caricare array NumPy da testo
Creare array con l'aiuto di segnaposto iniziali o con qualche dato di esempio è un ottimo modo per iniziare con numpy. Ma quando vuoi iniziare con l'analisi dei dati, dovrai caricare dati da file di testo.
Con quello che hai visto finora, non riuscirai a fare molto. Usa alcune funzioni specifiche per caricare dati dai tuoi file, come loadtxt() o genfromtxt().
Mettiamo che tu abbia i seguenti file di testo con dati, vorresti copiare e incollare i valori commentati nel codice qui sotto, incollarli nel file di testo e salvarlo come “data.txt”. Puoi quindi usare il codice seguente:
# This is your data in the text file
# Value1 Value2 Value3
# 0.2536 0.1008 0.3857
# 0.4839 0.4536 0.3561
# 0.1292 0.6875 0.5929
# 0.1781 0.3049 0.8928
# 0.6253 0.3486 0.8791
# Import your data
x, y, z = np.loadtxt('data.txt',
skiprows=1,
unpack=True)Nel codice sopra, usi loadtxt() per caricare i dati nel tuo ambiente. Vedi che il primo argomento che entrambe le funzioni prendono è il file di testo data.txt. Poi, ci sono alcuni argomenti specifici per ciascuna: nella prima istruzione, salti la prima riga e restituisci le colonne come array separati con unpack=TRUE. Ciò significa che i valori nella colonna Value1 saranno messi in x, e così via.
Nota che, nel caso tu abbia dati separati da virgole o se vuoi specificare il tipo di dato, ci sono anche gli argomenti delimiter e dtype che puoi aggiungere agli argomenti di loadtxt().
Facile e lineare, giusto?
Diamo un'occhiata al tuo secondo file con dati:
# Your data in the text file
# Value1 Value2 Value3
# 0.4839 0.4536 0.3561
# 0.1292 0.6875 MISSING
# 0.1781 0.3049 0.8928
# MISSING 0.5801 0.2038
# 0.5993 0.4357 0.7410
my_array2 = np.genfromtxt('data2.txt',
skip_header=1,
filling_values=-999)Vedi che qui ricorri a genfromtxt() per caricare i dati. In questo caso, devi gestire alcuni valori mancanti indicati dalle stringhe 'MISSING'.
Poiché la funzione genfromtxt() converte le stringhe di caratteri in colonne numeriche in nan, puoi convertire questi valori in altri specificando l'argomento filling_values. In questo caso, scegli di impostare il valore di questi mancanti a -999.
Se, per caso, hai valori che non vengono convertiti in nan da genfromtxt(), c'è sempre l'argomento missing_values che ti permette di specificare quali sono esattamente i valori mancanti dei tuoi dati.
Ma non è tutto.
Consiglio: consulta questa pagina su numpy.genfromtxt per vedere quali altri argomenti puoi aggiungere per importare correttamente i tuoi dati.
Ora potresti chiederti qual è davvero la differenza tra queste due funzioni.
Gli esempi lo mostrano forse implicitamente, ma in generale genfromtxt() ti dà un po' più di flessibilità; È più robusta di loadtxt().
Rendiamo questa differenza un po' più pratica: la seconda, loadtxt(), funziona solo quando ogni riga nel file di testo ha lo stesso numero di valori, quindi quando vuoi gestire facilmente i valori mancanti, in genere troverai più facile usare genfromtxt().
Ma non è certo l'unico motivo.
Un rapido sguardo al numero di argomenti che genfromtxt() offre ti insegnerà che ci sono molte più cose che puoi specificare nell'import, come il numero massimo di righe da leggere o l'opzione per rimuovere automaticamente gli spazi bianchi dalle variabili.
Come salvare array NumPy
Dopo aver fatto tutto ciò che ti serve con i tuoi array, puoi anche salvarli su file. Se vuoi salvare l'array in un file di testo, puoi usare la funzione savetxt() per farlo:
import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')Ricorda che np.arange() crea un array NumPy di valori equidistanti. Il terzo valore che passi a questa funzione è il passo.
Ci sono, ovviamente, altri modi per salvare i tuoi array NumPy su file di testo. Dai un'occhiata alle funzioni nella tabella qui sotto se vuoi portare i tuoi dati su file binari o archivi:
| save() | Salva un array in un file binario nel formato .npy di NumPy |
| savez() | Salva più array in un archivio .npz non compresso |
| savez_compressed() | Salva più array in un archivio .npz compresso |
Per maggiori informazioni o esempi su come puoi usare le funzioni sopra per salvare i tuoi dati, consulta questa pagina di riferimento di NumPy o usa una delle funzioni di help che NumPy mette a disposizione per saperne di più al volo!
Non sei sicuro di quali siano queste funzioni di help di NumPy?
Nessun problema! Ne imparerai di più in una delle prossime sezioni!
Come ispezionare i tuoi array NumPy
Oltre agli attributi degli array menzionati sopra, cioè data, shape, dtype e strides, ce ne sono altri che puoi usare per conoscere facilmente meglio i tuoi array. Quelli che potresti trovare interessanti quando stai iniziando sono i seguenti:
import numpy as np
# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()
# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()
# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()
# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()
# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()Questi sono quasi tutti gli attributi che un array può avere.
Non preoccuparti se non senti che tutti siano utili per te in questo momento. È abbastanza normale perché, proprio come hai letto nella sezione precedente, ti preoccuperai della memoria solo quando lavori con dataset di grandi dimensioni.
Nota anche che, oltre agli attributi, hai anche altri modi per ottenere più informazioni e persino modificare leggermente il tuo array:
import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print the length of `my_array`
print(len(my_array))
# Change the data type of `my_array`
my_array.astype(float)Ora che hai creato il tuo array, sia facendone uno tu stesso con np.array() o una delle funzioni di segnaposto iniziali, sia caricando i tuoi dati tramite le funzioni loadtxt() o genfromtxt(), è il momento di guardare più da vicino il secondo elemento chiave che definisce davvero la libreria NumPy: il calcolo scientifico.
Come funziona il broadcasting in NumPy
Prima di approfondire il calcolo scientifico, potrebbe essere una buona idea rivedere prima cos'è esattamente il broadcasting: è un meccanismo che permette a NumPy di lavorare con array di forme diverse quando stai eseguendo operazioni aritmetiche.
L'infografica qui sotto mostra un esempio di broadcasting di NumPy in azione:
Per metterla in un contesto più pratico, spesso hai un array un po' più grande e un altro leggermente più piccolo. Idealmente, vuoi usare l'array più piccolo più volte per eseguire un'operazione (come somma, moltiplicazione, ecc.) su quello più grande.
Per farlo, usi il meccanismo di broadcasting.
Tuttavia, ci sono alcune regole se vuoi usarlo. E, prima che tu sospiri, vedrai che queste “regole” sono molto semplici e piuttosto intuitive!
- Per prima cosa, per assicurarti che il broadcasting abbia successo, le dimensioni dei tuoi array devono essere compatibili. Due dimensioni sono compatibili quando sono uguali. Considera il seguente esempio:
# Import the NumPy library and give it an alias of `np`
import numpy as np
# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))
# Print the shape of the array `x`
print("Shape of x:", x.shape)
# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))
# Print the shape of the array `y`
print("Shape of y:", y.shape)
# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)
# Print the shape of the resulting array
print("Shape of x + y:", z.shape)- Due dimensioni sono anche compatibili quando una di esse è 1:
# Import the NumPy library and give it an alias of `np`
import numpy as np
# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))
# Print the shape of the array `x`
print("Shape of x:", x.shape)
# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))
# Print the shape of the array `y`
print("Shape of y:", y.shape)
# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)
# Print the shape of the resulting array
print("Shape of x + y:", z.shape)Nota che se le dimensioni non sono compatibili, otterrai un ValueError.
Consiglio: testa anche qual è la dimensione dell'array risultante dopo aver eseguito i calcoli! Vedrai che la dimensione è in realtà la misura massima lungo ciascuna dimensione degli array di input.
In altre parole, vedi che il risultato di x-y dà un array con shape (3,4): y aveva una shape di (4,) e x aveva una shape di (3,4). La dimensione massima lungo ciascuna dimensione di x e y è presa per comporre la shape del nuovo array risultante.
- Infine, gli array possono essere messi in broadcasting insieme solo se sono compatibili in tutte le dimensioni. Considera il seguente esempio:
# Import `numpy` as `np`
import numpy as np
# Initialize `x` and `y`
x = np.ones((3,4))
y = np.random.random((5,1,4))
# Add `x` and `y`
z = x + y
Vedi che, anche se x e y sembrano avere dimensioni un po' diverse, i due possono essere sommati.
Questo perché sono compatibili in tutte le dimensioni:
- L'array x ha dimensioni 3 X 4,
- L'array y ha dimensioni 5 X 1 X 4
Poiché hai visto sopra che le dimensioni sono anche compatibili se una di esse è uguale a 1, vedi che questi due array sono davvero un buon candidato per il broadcasting!
Noterai che nella dimensione in cui y ha dimensione 1 e l'altro array ha dimensione maggiore di 1 (cioè 3), il primo array si comporta come se fosse copiato lungo quella dimensione.
Nota che la shape dell'array risultante sarà di nuovo la dimensione massima lungo ciascuna dimensione di x e y: la dimensione del risultato sarà (5,3,4)
In breve, se vuoi usare il broadcasting, farai molto affidamento sulla shape e sulle dimensioni degli array con cui stai lavorando.
Ma cosa succede se le dimensioni non sono compatibili?
E se non sono uguali o se una di esse non è uguale a 1?
Dovrai risolverlo manipolando il tuo array! Vedrai come farlo in una delle prossime sezioni.
Come funzionano le operazioni matematiche sugli array?
Hai visto che il broadcasting è utile quando esegui operazioni aritmetiche. In questa sezione, scoprirai alcune delle funzioni che puoi usare per fare matematica con gli array.
Di conseguenza, probabilmente non ti sorprenderà che tu possa semplicemente usare +, -, *, / o % per sommare, sottrarre, moltiplicare, dividere o calcolare il resto di due (o più) array. Tuttavia, una grande parte del motivo per cui NumPy è così utile è che ha anche funzioni per farlo. Le funzioni equivalenti alle operazioni che hai appena visto sono, rispettivamente, np.add(), np.subtract(), np.multiply(), np.divide() e np.remainder().
Puoi anche fare facilmente esponenziazione e radice quadrata dei tuoi array con np.exp() e np.sqrt(), o calcolare seni e coseni del tuo array con np.sin() e np.cos(). Infine, è utile menzionare che c'è anche un modo per calcolare il logaritmo naturale con np.log() o calcolare il prodotto scalare applicando dot() al tuo array.
Prova tutto nel codice qui sotto.
Solo un consiglio: assicurati prima di controllare gli array che sono stati caricati per questo esercizio!
# Import `numpy` as `np`
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5]])
y = np.array([6,7,8])
# Add `x` and `y`
z = np.add(x,y)
print("Addition of x and y:\n", z)
# Subtract `x` and `y`
z = np.subtract(x,y)
print("Subtraction of y from x:\n", z)
# Multiply `x` and `y`
z = np.multiply(x,y)
print("Element-wise multiplication of x and y:\n", z)Ricordi come funziona il broadcasting? Controlla le dimensioni e le shape sia di x che di y nella tua shell IPython. Le regole del broadcasting sono rispettate?
Ma c'è di più.
Dai un'occhiata a questo piccolo elenco di funzioni di aggregazione:
| a.sum() | Somma su tutto l'array |
| a.min() | Valore minimo dell'array |
| b.max(axis=0) | Valore massimo di una riga dell'array |
| b.cumsum(axis=1) | Somma cumulativa degli elementi |
| a.mean() | Media |
| b.median() | Mediana |
| a.corrcoef() | Coefficiente di correlazione |
| np.std(b) | Deviazione standard |
Oltre a tutte queste funzioni, potresti anche trovare utile sapere che esistono meccanismi che ti permettono di confrontare elementi degli array. Ad esempio, se vuoi verificare se gli elementi di due array sono uguali, puoi usare l'operatore ==. Per controllare se gli elementi dell'array sono più piccoli o più grandi, usi gli operatori < o >.
Tutto questo sembra piuttosto semplice, vero?
Tuttavia, puoi anche confrontare interi array tra loro! In questo caso, usi la funzione np.array_equal(). Basta passare i due array che vuoi confrontare tra loro e hai finito.
Nota che, oltre a confrontare, puoi anche eseguire operazioni logiche sui tuoi array. Puoi iniziare con np.logical_or(), np.logical_not() e np.logical_and(). Questo funziona sostanzialmente come le tue tipiche operazioni logiche OR, NOT e AND;
Nell'esempio più semplice, usi OR per vedere se i tuoi elementi sono uguali (ad esempio, 1), o se uno dei due elementi dell'array è 1. Se entrambi sono 0, restituirai FALSE. Useresti AND per vedere se anche il tuo secondo elemento è 1 e NOT per vedere se il secondo elemento differisce da 1.
Provalo nel blocco di codice qui sotto:
# Import `numpy` as `np`
import numpy as np
# Initialize arrays
a = np.array([1, 1, 0, 0], dtype=bool)
b = np.array([1, 0, 1, 0], dtype=bool)
# `a` AND `b`
np.logical_and(a, b)
# `a` OR `b`
np.logical_or(a, b)
# `a` NOT `b`
np.logical_not(a,b)Come fare subset, slicing e indicizzazione degli array
Oltre alle operazioni matematiche, potresti anche voler prendere solo una parte dell'array originale (o dell'array risultante) o solo alcuni elementi dell'array da usare in ulteriori analisi o altre operazioni. In tal caso, dovrai fare subset, slicing e/o indicizzazione dei tuoi array.
Queste operazioni sono molto simili a quando le esegui sulle liste Python. Se vuoi verificare di persona le somiglianze, o se vuoi una spiegazione più approfondita, potresti considerare di consultare il tutorial sulle liste in Python di DataCamp.
Se non hai proprio idea di come funzionino queste operazioni, per ora basta sapere queste due cose di base:
- Usi le parentesi quadre [] come operatore di indice, e
- In genere, passi interi a queste parentesi quadre, ma puoi anche mettere i due punti : o una combinazione di due punti con interi per indicare gli elementi/righe/colonne che vuoi selezionare.
Subsetting
Oltre a questi due punti, il modo più semplice per vedere come tutto si incastra è guardare alcuni esempi di subsetting:
import numpy as np
# Initialize 1D array
my_array = np.array([1,2,3,4])
# Print subsets
print(my_array[1])import numpy as np
# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print subsets
print(my_2d_array[1][2])
print(my_2d_array[1,2])import numpy as np
# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Print subset
print(my_3d_array[1,1,2])Slicing
Qualcosa di un po' più avanzato del subsetting, se vuoi, è lo slicing. Qui, non consideri solo particolari valori dei tuoi array, ma vai al livello di righe e colonne. In pratica, lavori con “regioni” di dati invece di pure “posizioni”.
Puoi vedere cosa si intende con questa analogia in questi esempi di codice:
import numpy as np
# Initialize 1D array
my_array = np.array([1,2,3,4])
# Print subsets
print(my_array[0:2])import numpy as np
# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print subsets
print(my_2d_array[0:2,1])import numpy as np
# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Print subset
print(my_3d_array[1,...])Vedrai che, in sostanza, vale quanto segue:
a[start:end] # items start through the end (but the end is not included!)
a[start:] # items start through the rest of the array
a[:end] # items from the beginning through the end (but the end is not included!)Nel codice sopra, ogni array è inizializzato separatamente e i subset sono stampati in blocchi di codice separati. my_array, my_2d_array e my_3d_array sono rispettivamente gli array 1D, 2D e 3D, e i subset sono stampati usando la notazione di indicizzazione.
Nel primo esempio, usiamo lo slicing per selezionare gli elementi agli indici 0 e 1 di my_array. Nel secondo esempio, usiamo lo slicing per selezionare gli elementi alle righe 0 e 1, colonna 1 di my_2d_array. Nel terzo esempio, usiamo la notazione ... per selezionare tutti gli elementi lungo la prima e la seconda dimensione e il secondo elemento lungo la terza dimensione di my_3d_array.
Indicizzazione
Infine, c'è anche l'indicizzazione. In NumPy, esistono l'indicizzazione booleana e l'indicizzazione avanzata o “fancy”.
(Nel caso te lo stessi chiedendo, questo è vero gergo di NumPy, non me lo sono inventato!)
Per prima, l'indicizzazione booleana. Qui, invece di selezionare elementi, righe o colonne in base al numero di indice, selezioni quei valori dal tuo array che soddisfano una certa condizione.
Mettere questo in codice può essere piuttosto semplice:
import numpy as np
my_array = np.array([1,2,3,4])
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Try out a simple example
print(my_array[my_array<2])
# Specify a condition
bigger_than_3 = (my_3d_array >= 3)
# Use the condition to index our 3d array
print(my_3d_array[bigger_than_3])Nota che per specificare una condizione puoi anche usare gli operatori logici | (OR) e & (AND). Se volessi riscrivere la condizione sopra in questo modo (sarebbe inefficiente, ma lo mostro qui a scopo didattico :)), otterresti bigger_than_3 = (my_3d_array > 3) | (my_3d_array == 3).
Con gli array caricati qui, non ci sono troppe possibilità, ma con array che contengono, ad esempio, nomi o capitali, le possibilità potrebbero essere infinite!
Per quanto riguarda la fancy indexing, ciò che fai sostanzialmente è: passi una lista o un array di interi per specificare l'ordine del sottoinsieme di righe che vuoi selezionare dall'array originale.
Ti suona un po' astratto?
Nessun problema, provalo nel blocco di codice qui sotto:
import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Select elements at (1,0), (0,1), (1,2) and (0,0)
print(my_2d_array[[1, 0, 1, 0],[0, 1, 2, 0]])
# Select a subset of the rows and columns
print(my_2d_array[[1, 0, 1, 0]][:,[0,1,2,0]])Ora, la seconda istruzione potrebbe sembrarti meno sensata a prima vista. È normale. Potrebbe essere più chiaro se la scomponi:
- Se esegui solo my_2d_array[[1,0,1,0]], il risultato è il seguente:
array([[5, 6, 7, 8],
[1, 2, 3, 4],
[5, 6, 7, 8],
[1, 2, 3, 4]])- Quello che la seconda parte, cioè [:,[0,1,2,0]], ti dice è che vuoi mantenere tutte le righe di questo risultato, ma che vuoi cambiare un po' l'ordine delle colonne. Vuoi visualizzare le colonne 0, 1 e 2 così come sono ora, ma vuoi ripetere la colonna 0 come ultima colonna invece di visualizzare la colonna numero 3. Questo ti darà il seguente risultato:
array([[5, 6, 7, 5],
[1, 2, 3, 1],
[5, 6, 7, 5],
[1, 2, 3, 1]])L'indicizzazione avanzata ormai non ha più segreti per te!
Come chiedere aiuto
Come breve intermezzo, dovresti sapere che puoi sempre chiedere più informazioni sui moduli, le funzioni o le classi con cui stai lavorando, soprattutto perché NumPy può essere qualcosa di impegnativo quando inizi a lavorarci.
Chiedere aiuto è abbastanza semplice.
Usi semplicemente le funzioni di help specifiche che numpy offre per metterti sulla strada giusta:
- Usa lookfor() per fare una ricerca per parola chiave nelle docstring. Questo è particolarmente utile se stai iniziando, poiché la “teoria” alla base potrebbe svanire nella memoria. L'unico svantaggio è che devi scorrere tutti i risultati della ricerca se la tua query non è così specifica, come nel caso dell'esempio di codice sotto. Questo potrebbe renderla ancora meno agevole per te.
- Usa info() per spiegazioni rapide ed esempi di codice di funzioni, classi o moduli. Se sei una persona che impara facendo, questo è il modo giusto! L'unico svantaggio nell'usare questa funzione è probabilmente che devi essere consapevole del modulo in cui si trovano certi attributi o funzioni. Se non sai subito cosa si intende, controlla l'esempio di codice qui sotto.
Vedi, entrambe le funzioni hanno vantaggi e svantaggi, ma vedrai da solo perché entrambe possono essere utili: provale nel blocco di codice qui sotto!
import numpy as np
# Look up info on `mean` with `np.lookfor()`
print(np.lookfor("mean"))# Get info on data types with `np.info()`
np.info(np.ndarray.dtype)Nota che devi effettivamente sapere che dtype è un attributo di ndarray. Inoltre, assicurati di non dimenticare di mettere np davanti ai moduli, classi o termini di cui chiedi informazioni, altrimenti otterrai un messaggio di errore come questo:
Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'ndarray' is not defined
Ora sai come chiedere aiuto, ed è una buona cosa. Il prossimo argomento che questo tutorial su NumPy copre è la manipolazione degli array.
Non che tu non possa affrontare questo argomento da solo, tutt'altro!
Ma alcune funzioni potrebbero sollevare domande, perché, qual è la differenza tra ridimensionamento e reshaping?
E qual è la differenza tra concatenare i tuoi array in orizzontale e in verticale?
La prossima sezione risponde a queste domande, ma se mai avessi dubbi, sentiti libero di usare le funzioni di help che hai appena visto per rimetterti subito in carreggiata.
Come manipolare gli array
Eseguire operazioni matematiche sui tuoi array è una delle cose che farai, ma probabilmente la più importante per far funzionare questo e il broadcasting è sapere come manipolare i tuoi array.
Di seguito trovi alcune delle manipolazioni più comuni che farai.
Come trasporre i tuoi array
Trasporre i tuoi array significa in realtà permutare le loro dimensioni. O, in altre parole, scambi la forma dell'array. Facciamo un piccolo esempio per mostrare l'effetto della trasposizione:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_2d_array`
print(my_2d_array)
# Transpose `my_2d_array`
print(np.transpose(my_2d_array))
# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)Consiglio: se il confronto visivo tra l'array e la sua versione trasposta non è del tutto chiaro, ispeziona la shape dei due array per assicurarti di capire perché le dimensioni sono permutate.
Nota che ci sono due funzioni di trasposizione. Fanno entrambe la stessa cosa; Non c'è molta differenza. Devi però considerare che T sembra più una scorciatoia e che hai molta più flessibilità con np.transpose(). Ecco perché si raccomanda di usare questa funzione se vuoi più argomenti.
Tutto bene quando trasponi array più grandi di una dimensione, ma cosa succede quando hai solo un array 1-D? Pensi che ci sarà qualche effetto?
Provalo da solo nel blocco di codice qui sotto. Il tuo array 1-D è già stato caricato:
import numpy as np
my_array = np.array([1,2,3,4])
# Print `my_2d_array
print(my_array)
# Transpose `my_2d_array
print(np.transpose(my_array))
# Or use `T` to transpose `my_2d_array
print(my_array.T)Hai perfettamente ragione! Non c'è alcun effetto quando trasponi un array 1-D!
Reshaping vs. resizing degli array
Potresti aver letto nella sezione sul broadcasting che le dimensioni dei tuoi array devono essere compatibili se vuoi che siano buoni candidati per le operazioni aritmetiche. Ma la domanda su cosa dovresti fare quando non è così non è stata ancora risposta.
Bene, ecco la risposta!
Quello che puoi fare se gli array non hanno le stesse dimensioni è ridimensionare il tuo array. Restituirai quindi un nuovo array che ha la shape che hai passato alla funzione np.resize(). Se passi il tuo array originale insieme alle nuove dimensioni, e se quel nuovo array è più grande di quello che avevi originariamente, il nuovo array sarà riempito con copie dell'array originale ripetute tante volte quante sono necessarie.
Tuttavia, se applichi semplicemente np.resize() all'array e gli passi la nuova shape, il nuovo array sarà riempito di zeri.
Proviamo con un esempio:
import numpy as np
x = np.ones((3,4))
# Print the shape of `x`
print(x.shape)
# Resize `x` to ((6,4))
np.resize(x, (6,4))
# Try out this as well
x.resize((6,4))
# Print out `x`
print(x)Oltre al ridimensionamento, puoi anche fare il reshape del tuo array. Questo significa che dai una nuova forma a un array senza cambiarne i dati. La chiave del reshaping è assicurarsi che la dimensione totale del nuovo array non cambi. Se prendi l'esempio dell'array x usato sopra, che ha dimensione 3 X 4 ovvero 12, devi assicurarti che il nuovo array abbia anch'esso dimensione 12.
Psst… Se vuoi calcolare la dimensione di un array con il codice, usa l'attributo size: x.size o x.reshape((2,6)).size:
import numpy as np
# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))
# Print the shape of `x`
print("Shape of x:", x.shape)
# Resize `x` to ((6,4))
np.resize(x, (6,4))
# Try out this as well
x.resize((6,4))
# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)
# Transpose `x`
x = x.T
# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)Output:
Shape of x: (3, 4)
Array before transposing:
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
[[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)Se tutto il resto fallisce, puoi anche aggiungere un array al tuo originale o inserire o eliminare elementi dell'array per assicurarti che le tue dimensioni si adattino all'altro array che vuoi usare per i calcoli.
Un'altra operazione che potresti tenere a portata di mano quando cambi la forma degli array è ravel(). Questa funzione ti permette di appiattire i tuoi array. Significa che se hai array 2D, 3D o n-D, puoi usare questa funzione per appiattire tutto in un array 1-D.
Abbastanza comodo, no?
Come fare append degli array
Quando esegui l'append di array al tuo array originale, vengono “incollati” alla fine di quell'array originale. Se vuoi assicurarti che ciò che aggiungi non arrivi alla fine dell'array, potresti considerare di inserirlo. Vai alla sezione successiva se vuoi saperne di più.
L'append è piuttosto semplice grazie alla libreria NumPy; Puoi semplicemente usare np.append().
Guarda come si fa nel blocco di codice sotto. Non dimenticare che puoi sempre controllare quali array sono caricati digitando, ad esempio, my_array nella shell IPython e premendo INVIO.
import numpy as np
my_array = np.array([1,2,3,4])
# Print `my_array` before appending
print("my_array before appending:", my_array)
# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])
# Print `new_array`
print("new_array:", new_array)
# Print `my_array` after appending
print("my_array after appending:", my_array)Output:
my_array before appending: [1 2 3 4]
new_array: [ 1 2 3 4 7 8 9 10]
my_array after appending: [1 2 3 4]Nota che my_array rimane invariato dopo l'append perché np.append() restituisce un nuovo array invece di modificare in place l'array originale.
Append a my_2d_array:
import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)
# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)
# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)
# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)Output:
my_2d_array before appending:
[[1 2 3 4]
[5 6 7 8]]
new_2d_array:
[[1 2 3 4 7]
[5 6 7 8 8]]
my_2d_array after appending:
[[1 2 3 4]
[5 6 7 8]]
Nota come, quando aggiungi una colonna extra a my_2d_array, venga specificato l'asse. Ricorda che l'asse 1 indica le colonne, mentre l'asse 0 indica le righe negli array 2-D.
Come inserire ed eliminare elementi dell'array
Oltre all'append, puoi anche inserire ed eliminare elementi dell'array. Come avrai ormai intuito, le funzioni che ti permettono di eseguire queste operazioni sono np.insert() e np.delete():
import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Insert `5` at index 1
np.insert(my_array, 1, 5)
# Delete the value at index 1
np.delete(my_array,[1])Come unire e dividere array
Puoi anche “unire” o concatenare i tuoi array. Ci sono diverse funzioni che puoi usare a questo scopo e la maggior parte sono elencate di seguito.
Provale, ma assicurati anche di testare qual è la shape degli array nella shell IPython. Gli array caricati sono x, my_array, my_resized_array e my_2d_array.
import numpy as np
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))
# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))
# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])
# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))
# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))
# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])Noterai alcune cose mentre scorri le funzioni:
- Il numero di dimensioni deve essere lo stesso se vuoi concatenare due array con np.concatenate(). Pertanto, se vuoi concatenare un array con my_array, che è 1-D, devi assicurarti che il secondo array che hai sia anch'esso 1-D.
- Con np.vstack(), combini senza sforzo my_array con my_2d_array. Devi solo assicurarti che, mentre stai impilando gli array per righe, il numero di colonne in entrambi gli array sia lo stesso. Pertanto, potresti anche aggiungere un array con shape (2,4) o (3,4) a my_2d_array, purché il numero di colonne corrisponda. In altre parole, gli array devono avere la stessa shape lungo tutti gli assi tranne il primo. Lo stesso vale anche quando vuoi usare np.r[].
- Per np.hstack(), devi assicurarti che il numero di dimensioni sia lo stesso e che il numero di righe in entrambi gli array sia lo stesso. Ciò significa che potresti impilare array come (2,3) o (2,4) a my_2d_array, che ha shape (2,4). È tutto possibile purché tu faccia in modo che il numero di righe corrisponda. Questa funzione è ancora supportata da NumPy, ma dovresti preferire np.concatenate() o np.stack().
- Con np.column_stack(), devi assicurarti che gli array in input abbiano la stessa prima dimensione. In questo caso, entrambe le shape sono uguali, ma se my_resized_array fosse (2,1) o (2,), gli array sarebbero comunque stati impilati.
- np.c_[] è un altro modo per concatenare. Anche qui, la prima dimensione di entrambi gli array deve corrispondere.
Quando hai unito gli array, potresti anche volerli dividere a un certo punto. Proprio come puoi impilarli orizzontalmente, puoi fare lo stesso ma verticalmente. Usi rispettivamente np.hsplit() e np.vsplit():
import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))
# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))
# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))Quello che devi tenere a mente quando usi entrambe queste funzioni di split è probabilmente la shape del tuo array. Prendiamo il caso sopra come esempio: my_stacked_array ha shape (2,8). Se vuoi selezionare l'indice a cui vuoi che avvenga la divisione, devi tenere a mente la shape.
Come visualizzare array NumPy
Infine, qualcosa che sarà sicuramente utile è sapere come puoi tracciare i tuoi array. Questo può essere particolarmente utile nell'esplorazione dei dati, ma anche nelle fasi successive del flusso di lavoro di data science, quando vuoi visualizzare i tuoi array.
Con np.histogram()
Contrariamente a quanto potrebbe suggerire la funzione, np.histogram() non disegna l'istogramma ma calcola quante occorrenze dell'array ricadono in ciascun bin; Questo determinerà l'area che ogni barra del tuo istogramma occupa.
Ciò che passi alla funzione np.histogram() è prima di tutto l'input dei dati o l'array con cui stai lavorando. L'array sarà appiattito quando l'istogramma viene calcolato.
# Import `numpy` as `np`
import numpy as np
# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)
# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))
# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))Vedrai che come risultato l'istogramma verrà calcolato: il primo array elenca le frequenze per tutti gli elementi del tuo array, mentre il secondo array elenca i bin che verrebbero usati se non specifichi alcun bin.
Se specifichi un numero di bin, il risultato del calcolo sarà diverso: i float spariranno e vedrai solo interi per i bin.
Ci sono ancora altri argomenti che puoi specificare e che possono influenzare l'istogramma calcolato. Puoi trovarli tutti qui.
Ma qual è il senso di calcolare un istogramma se non puoi visualizzarlo?
La visualizzazione è un gioco da ragazzi con l'aiuto di Matplotlib, ma non ti serve np.histogram() per calcolare l'istogramma. plt.hist() lo fa da sé quando gli passi i dati (appiattiti) e i bin:
# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt
# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))
# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')
# Show the plot
plt.show()Il codice sopra ti darà quindi il seguente istogramma (di base):
Usare np.meshgrid()
Un altro modo per visualizzare (indirettamente) il tuo array è usare np.meshgrid(). Il problema che affronti con gli array è che ti servono array 2-D di valori di coordinate x e y. Con la funzione sopra, puoi creare una griglia rettangolare a partire da un array di valori x e un array di valori y: la funzione np.meshgrid() prende due array 1D e produce due matrici 2D corrispondenti a tutte le coppie (x, y) nei due array. Poi, puoi usare queste matrici per creare tutti i tipi di grafici.
np.meshgrid() è particolarmente utile se vuoi valutare funzioni su una griglia, come dimostra il codice qui sotto:
# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt
# Create an array
points = np.arange(-5, 5, 0.01)
# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)
# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)
# Draw a color bar
plt.colorbar()
# Show the plot
plt.show()Il codice sopra dà il seguente risultato:
Oltre l'analisi dei dati con NumPy
Congratulazioni, sei arrivato alla fine del tutorial su NumPy!
Hai coperto molto terreno, quindi ora devi assicurarti di mantenere le conoscenze acquisite. Non dimenticare di procurarti una copia del cheat sheet di NumPy di DataCamp per aiutarti in questo!
Dopo tutta questa teoria, è anche il momento di fare un po' più di pratica con i concetti e le tecniche che hai imparato in questo tutorial. Un modo per farlo è tornare al tutorial su scikit-learn e iniziare a sperimentare ulteriormente con gli array di dati usati per costruire modelli di machine learning.
Se questo non fa per te, verifica di nuovo se hai scaricato Anaconda. Poi, inizia con gli array NumPy in Jupyter con questa Guida definitiva a Jupyter Notebook. Assicurati anche di dare un'occhiata a questo Jupyter Notebook, che ti guida anche attraverso l'analisi dei dati in Python con NumPy e altre librerie nell'ambiente interattivo di data science di Jupyter Notebook.
Infine, considera di dare un'occhiata ai corsi di DataCamp sulla manipolazione e visualizzazione dei dati. In particolare i nostri ultimi corsi in collaborazione con Continuum Analytics ti interesseranno sicuramente! Dai un'occhiata ai corsi Manipulating DataFrames with Pandas o Pandas Foundations.
Argomenti
