Tutorial NumPy: Analisi dei dati con Python

Non perdere il nostro FREE NumPy cheat sheet in fondo a questo post

NumPy è un pacchetto di analisi dei dati comunemente usato in Python. Usando NumPy, puoi accelerare il tuo flusso di lavoro e interfacciarti con altri pacchetti dell’ecosistema Python, come scikit-learn, che usano NumPy sotto il cofano. NumPy è stato originariamente sviluppato a metà degli anni 2000, ed è nato da un pacchetto ancora più vecchio chiamato Numeric. Questa longevità significa che quasi ogni pacchetto di analisi dei dati o di apprendimento automatico per Python sfrutta NumPy in qualche modo.

In questo tutorial, useremo NumPy per analizzare i dati sulla qualità del vino. I dati contengono informazioni su vari attributi dei vini, come pH e fixed acidity, insieme a un punteggio di qualità tra 0 e 10 per ogni vino. Il punteggio di qualità è la media di almeno 3 tester di gusto umani. Mentre impariamo a lavorare con NumPy, cercheremo di capire di più sulla qualità percepita del vino.

I vini che analizzeremo sono della regione del Minho in Portogallo.

I dati sono stati scaricati dall’UCI Machine Learning Repository, e sono disponibili qui. Ecco le prime righe del file winequality-red.csv, che useremo durante questo tutorial:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

I dati sono in quello che chiamerò formato ssv (semicolon separated values) – ogni record è separato da un punto e virgola (;), e le righe sono separate da una nuova linea. Ci sono 1600 righe nel file, inclusa una riga di intestazione, e 12 colonne.

Prima di iniziare, una breve nota sulla versione – useremo Python 3.5. I nostri esempi di codice saranno fatti usando Jupyter notebook.

Liste di liste per dati CSV

Prima di usare NumPy, proveremo a lavorare con i dati usando Python e il pacchetto csv. Possiamo leggere il file usando l’oggetto csv.reader, che ci permetterà di leggere e dividere tutto il contenuto del file ssv.

Nel codice seguente, noi:

• Importiamo la libreria csv.
• Apriamo il file winequality-red.csv.
  • Con il file aperto, creiamo un nuovo oggetto csv.reader.
    • Passa l’argomento parola chiave delimiter=";" per assicurarti che i record siano divisi sul carattere punto e virgola invece del carattere virgola predefinito.
  • Chiamate il tipo di lista per ottenere tutte le righe dal file.
  • Assegnate il risultato a wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Una volta letti i dati, possiamo stampare le prime 3 righe:

print(wines)

, , ]

I dati sono stati letti in una lista di liste. Ogni lista interna è una riga del file ssv. Come avrete notato, ogni elemento nell’intera lista di liste è rappresentato come una stringa, il che renderà più difficile fare calcoli.

Formatteremo i dati in una tabella per renderli più facili da visualizzare:

Come potete vedere dalla tabella sopra, abbiamo letto tre righe, la prima delle quali contiene le intestazioni di colonna. Ogni riga dopo l’intestazione rappresenta un vino. Il primo elemento di ogni riga è il fixed acidity, il secondo è il volatile acidity, e così via. Possiamo trovare la media quality dei vini. Il codice seguente:

• Estrai l’ultimo elemento di ogni riga dopo la riga di intestazione.
• Converti ogni elemento estratto in un float.
• Assegna tutti gli elementi estratti alla lista qualities.
• Dividete la somma di tutti gli elementi in qualities per il numero totale di elementi in qualities per ottenere la media.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Anche se siamo riusciti a fare il calcolo che volevamo, il codice è abbastanza complesso, e non sarà divertente dover fare qualcosa di simile ogni volta che vogliamo calcolare una quantità. Fortunatamente, possiamo usare NumPy per facilitare il lavoro con i nostri dati.

Array bidimensionali Numpy

Con NumPy, lavoriamo con array multidimensionali. Ci immergeremo in tutti i possibili tipi di array multidimensionali più avanti, ma per ora, ci concentreremo sugli array bidimensionali. Un array bidimensionale è anche conosciuto come matrice, ed è qualcosa con cui dovresti avere familiarità. Infatti, è solo un modo diverso di pensare ad una lista di liste. Una matrice ha righe e colonne. Specificando un numero di riga e un numero di colonna, siamo in grado di estrarre un elemento da una matrice.

Nella matrice sottostante, la prima riga è la riga di intestazione e la prima colonna è la colonna fixed acidity:

Se scegliessimo l’elemento nella prima riga e nella seconda colonna, otterremmo volatile acidity. Se scegliessimo l’elemento nella terza riga e nella seconda colonna, otterremmo 0.88.

In un array NumPy, il numero di dimensioni è chiamato rango, e ogni dimensione è chiamata asse. Quindi le righe sono il primo asse e le colonne sono il secondo asse.

Ora che avete capito le basi delle matrici, vediamo come possiamo passare dalla nostra lista di liste ad un array NumPy.

Creare un array NumPy

Possiamo creare un array NumPy usando la funzione numpy.array. Se passiamo una lista di liste, creerà automaticamente un array NumPy con lo stesso numero di righe e colonne. Poiché vogliamo che tutti gli elementi dell’array siano elementi float per facilitare il calcolo, lasceremo fuori la riga di intestazione, che contiene le stringhe. Una delle limitazioni di NumPy è che tutti gli elementi di un array devono essere dello stesso tipo, quindi se includiamo la riga di intestazione, tutti gli elementi dell’array saranno letti come stringhe. Poiché vogliamo essere in grado di fare calcoli come trovare la media quality dei vini, abbiamo bisogno che gli elementi siano tutti float.

Nel codice seguente, noi:

• Importiamo il pacchetto numpy.
• Passiamo la lista di liste wines nella funzione array, che la converte in un array NumPy.
  • Escludiamo la riga di intestazione con lo slicing di lista.
  • Specifichiamo l’argomento parola chiave dtype per assicurarci che ogni elemento sia convertito in un float. Ci addentreremo di più su cosa sia il dtype più avanti.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Prova ad eseguire il codice sopra e vedi cosa succede!

Se visualizziamo wines, otterremo ora un array NumPy:

wines

array(,,,...,,,])

Possiamo controllare il numero di righe e colonne nei nostri dati usando la proprietà shape degli array NumPy:

wines.shape

(1599, 12)

Metodi alternativi di creazione degli array NumPy

Ci sono una varietà di metodi che puoi usare per creare gli array NumPy. Per cominciare, potete creare un array dove ogni elemento è zero. Il codice seguente creerà un array con 3righe e 4 colonne, dove ogni elemento è 0, usando numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

È utile creare un array con tutti elementi zero nei casi in cui si ha bisogno di un array di dimensione fissa, ma non si hanno ancora valori per esso.

È anche possibile creare un array dove ogni elemento è un numero casuale usando numpy.random.rand. Ecco un esempio:

np.random.rand(3,4)

array(,,])

Creare array pieni di numeri casuali può essere utile quando si vuole testare velocemente il proprio codice con array di esempio.

Usare NumPy per leggere i file

È possibile usare NumPy per leggere direttamente file csv o altri file in array. Possiamo farlo usando la funzione numpy.genfromtxt. Possiamo usarla per leggere i nostri dati iniziali sui vini rossi.

Nel codice seguente, noi:

• Utilizziamo la funzione genfromtxt per leggere il file winequality-red.csv.
• Specifichiamo l’argomento parola chiave delimiter=";" in modo che i campi siano analizzati correttamente.
• Specificare l’argomento parola chiave skip_header=1in modo che la riga di intestazione sia saltata.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines finirà per avere lo stesso aspetto che avrebbe se lo leggessimo in una lista e lo convertissimo in un array di float. NumPy sceglierà automaticamente un tipo di dati per gli elementi di un array in base al loro formato.

Indicizzare gli array di NumPy

Ora sappiamo come creare array, ma a meno che non possiamo recuperare risultati da essi, non c’è molto che possiamo fare con NumPy. Possiamo usare l’indicizzazione degli array per selezionare singoli elementi, gruppi di elementi o intere righe e colonne. Una cosa importante da tenere a mente è che proprio come le liste Python, NumPy è indicizzato a zero, il che significa che l’indice della prima riga è 0, e l’indice della prima colonna è 0. Se vogliamo lavorare con la quarta riga, useremo l’indice 3, se vogliamo lavorare con la seconda riga, useremo l’indice 1, e così via. Lavoreremo ancora con l’array wines:

Selezioniamo l’elemento alla riga 3 e colonna 4. Nel codice seguente, passiamo l’indice 2 come indice di riga e l’indice 3 come indice di colonna. Questo recupera il valore dalla quarta colonna della terza riga:

wines

2.2999999999999998

Siccome stiamo lavorando con un array bidimensionale in NumPy, specifichiamo 2 indici per recuperare un elemento. Il primo indice è la riga, o asse 1, e il secondo indice è la colonna, o asse 2. Qualsiasi elemento in wines può essere recuperato usando gli indici 2.

Slicing NumPy Arrays

Se invece vogliamo selezionare i primi tre elementi della quarta colonna, possiamo farlo usando i due punti (:). I due punti indicano che vogliamo selezionare tutti gli elementi dall’indice iniziale fino all’indice finale non incluso. Questo è anche noto come slice:

wines

array()

Proprio come con l’affettamento della lista, è possibile omettere il 0 per recuperare solo tutti gli elementi dall’inizio fino all’elemento 3:

wines

array()

Possiamo selezionare un’intera colonna specificando che vogliamo tutti gli elementi, dal primo all’ultimo. Lo specifichiamo usando solo i due punti (:), senza indici iniziali o finali. Il codice seguente selezionerà l’intera quarta colonna:

wines

array()

Abbiamo selezionato un’intera colonna sopra, ma possiamo anche estrarre un’intera riga:

wines

array()

Se portiamo la nostra indicizzazione all’estremo, possiamo selezionare l’intero array usando due punti per selezionare tutte le righe e colonne in wines. Questo è un grande trucco da festa, ma non ha molte buone applicazioni:

wines

array(,,<br />,<br />...,,,<br />])

Assegnare valori agli array NumPy

Possiamo anche usare l’indicizzazione per assegnare valori a certi elementi negli array. Possiamo farlo assegnando direttamente il valore indicizzato:

wines = 10

Possiamo fare lo stesso per le fette. Per sovrascrivere un’intera colonna, possiamo fare così:

wines = 50

Il codice qui sopra sovrascrive tutti i valori dell’undicesima colonna con 50.

Array NumPy 1-Dimensionali

Finora abbiamo lavorato con array bidimensionali, come wines. Tuttavia, NumPy è un pacchetto per lavorare con array multidimensionali. Uno dei tipi più comuni di array multidimensionali è l’array 1-dimensionale, o vettore. Come avrete notato sopra, quando abbiamo affettato wines, abbiamo recuperato un array 1-dimensionale. Un array 1-dimensionale ha bisogno di un solo indice per recuperare un elemento. Ogni riga e colonna in un array bidimensionale è un array 1-dimensionale. Proprio come una lista di liste è analoga ad un array bidimensionale, una singola lista è analoga ad un array 1-dimensionale. Se affettiamo i vini e recuperiamo solo la terza riga, otteniamo un array unidimensionale:

third_wine = wines

Ecco come appare third_wine:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Possiamo recuperare singoli elementi da third_wine usando un singolo indice. Il codice seguente visualizzerà il secondo elemento in third_wine:

third_wine

0.28000000000000003

La maggior parte delle funzioni NumPy con cui abbiamo lavorato, come numpy.random.rand, possono essere usate con array multidimensionali. Ecco come potremmo usare numpy.random.rand per generare un vettore casuale:

np.random.rand(3)

array()

In precedenza, quando abbiamo chiamato np.random.rand, abbiamo passato una forma per un array bidimensionale, quindi il risultato era un array bidimensionale. Questa volta, abbiamo passato una forma per un array monodimensionale. La forma specifica il numero di dimensioni e la dimensione dell’array in ogni dimensione. Una forma di (10,10) sarà un array bidimensionale con 10 righe e 10 colonne. Una forma di (10,) sarà un array 1-dimensionale con 10 elementi.

Il punto in cui NumPy diventa più complesso è quando iniziamo a trattare con array che hanno più di 2 dimensioni.

Array NumPy a N dimensioni

Questo non accade molto spesso, ma ci sono casi in cui vorrete avere a che fare con array che hanno più di 3 dimensioni. Un modo per pensare a questo è come una lista di liste di liste. Diciamo che vogliamo memorizzare i guadagni mensili di un negozio, ma vogliamo essere in grado di cercare rapidamente i risultati per un trimestre e per un anno. I guadagni di un anno potrebbero essere così:

Il negozio ha guadagnato 0 in gennaio, 5 in febbraio, e così via. Possiamo dividere questi guadagni per trimestre in una lista di liste:

year_one = , , , ]

Possiamo recuperare i guadagni di gennaio chiamando year_one. Se vogliamo i risultati di un intero trimestre, possiamo chiamare year_one o year_one. Ora abbiamo un array bidimensionale, o matrice. Ma cosa succede se ora vogliamo aggiungere i risultati di un altro anno? Dobbiamo aggiungere una terza dimensione:

earnings = , , , ], , , , ]]

Possiamo recuperare i guadagni da gennaio del primo anno chiamando earnings. Ora abbiamo bisogno di tre indici per recuperare un singolo elemento. Un array tridimensionale in NumPy è molto simile. Infatti, possiamo convertire earnings in un array e poi ottenere i guadagni di gennaio del primo anno:

earnings = np.array(earnings)earnings

500

Possiamo anche trovare la forma dell’array:

earnings.shape

(2, 4, 3)

L’indicizzazione e lo slicing funzionano esattamente allo stesso modo con un array tridimensionale, ma ora abbiamo un asse in più da passare. Se volessimo ottenere i guadagni di gennaio di tutti gli anni, potremmo fare così:

earnings

array()

Se volessimo ottenere i guadagni del primo trimestre di entrambi gli anni, potremmo fare così:

earnings

array(,])

L’aggiunta di più dimensioni può rendere molto più facile l’interrogazione dei dati se sono organizzati in un certo modo. Quando passiamo da array tridimensionali ad array quadridimensionali e più grandi, si applicano le stesse proprietà, e possono essere indicizzati e affettati negli stessi modi.

Tipi di dati NumPy

Come abbiamo detto prima, ogni array NumPy può contenere elementi di un singolo tipo di dati. Per esempio, wines contiene solo valori float. NumPy memorizza i valori usando i propri tipi di dati, che sono distinti dai tipi di Python come float e str. Questo perché il nucleo di NumPy è scritto in un linguaggio di programmazione chiamato C, che memorizza i dati in modo diverso dai tipi di dati Python. I tipi di dati NumPy mappano tra Python e C, permettendoci di usare gli array NumPy senza problemi di conversione.

Puoi trovare il tipo di dati di un array NumPy accedendo alla proprietà dtype:

wines.dtype

dtype('float64')

NumPy ha diversi tipi di dati, che principalmente mappano i tipi di dati Python, come float e str. Potete trovare un elenco completo dei tipi di dati NumPy qui, ma qui ce ne sono alcuni importanti:

• float – dati numerici in virgola mobile.
• int – dati interi.
• string – dati carattere.
• object – oggetti Python.

I tipi di dati terminano inoltre con un suffisso che indica quanti bit di memoria occupano. Così int32 è un tipo di dati intero a 32 bit e float64 è un tipo di dati float a 64 bit.

Conversione dei tipi di dati

È possibile utilizzare il metodo numpy.ndarray.astype per convertire un array in un tipo differente. Il metodo copierà effettivamente l’array e restituirà un nuovo array con il tipo di dati specificato. Per esempio, possiamo convertire wines nel tipo di dati int:

wines.astype(int)

array(,,,...,,,])

Come potete vedere sopra, tutti gli elementi nell’array risultante sono interi. Notate che abbiamo usato il tipo Python int invece di un tipo di dati NumPy quando abbiamo convertito wines. Questo perché diversi tipi di dati Python, inclusi float, int e string, possono essere usati con NumPy e sono automaticamente convertiti in tipi di dati NumPy.

Possiamo controllare la proprietà name del dtype dell’array risultante per vedere a quale tipo di dati NumPy ha mappato l’array risultante:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

L’array è stato convertito in un tipo di dati interi a 64 bit. Questo permette di avere valori interi molto lunghi, ma occupa più spazio in memoria rispetto alla memorizzazione dei valori come interi a 32 bit.

Se si desidera un maggiore controllo su come l’array viene memorizzato in memoria, è possibile creare direttamente oggetti di tipo NumPy come numpy.int32:

np.int32

numpy.int32

Puoi usarli direttamente per convertire tra tipi:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

Operazioni sulle matrici NumPy

NumPy rende semplice eseguire operazioni matematiche sulle matrici. Questo è uno dei vantaggi principali di NumPy, e rende abbastanza facile fare calcoli.

Matematica su singolo array

Se fai una qualsiasi delle operazioni matematiche di base (/, *, -, +, ^) con un array e un valore, verrà applicata l’operazione a ciascuno degli elementi dell’array.

Diciamo che vogliamo aggiungere 10 punti ad ogni punteggio di qualità perché siamo ubriachi e ci sentiamo generosi. Ecco come faremmo:

wines + 10

array()

Nota che l’operazione di cui sopra non cambierà l’array wines – restituirà un nuovo array 1-dimensionale dove 10 è stato aggiunto ad ogni elemento nella colonna della qualità dei vini.

Se invece facessimo +=, modificheremmo l’array al suo posto:

wines += 10wines

array()

Tutte le altre operazioni lavorano allo stesso modo. Per esempio, se vogliamo moltiplicare ogni punteggio di qualità per 2, potremmo farlo così:

wines * 2

array()

Matematica per matrici multiple

È anche possibile fare operazioni matematiche tra matrici. Questo applicherà l’operazione a coppie di elementi. Per esempio, se aggiungiamo la colonna quality a se stessa, ecco cosa otteniamo:

wines + wines

array()

Nota che questo è equivalente a wines * 2 – questo perché NumPy aggiunge ogni coppia di elementi. Il primo elemento del primo array viene aggiunto al primo elemento del secondo array, il secondo al secondo, e così via.

Possiamo anche usarlo per moltiplicare gli array. Diciamo che vogliamo scegliere un vino che massimizzi il contenuto alcolico e la qualità (vogliamo ubriacarci, ma siamo di classe). Moltiplichiamo alcohol per quality, e selezioniamo il vino con il punteggio più alto:

wines * wines

array()

Tutte le operazioni comuni (/, *, -, +, ^) funzioneranno tra gli array.

Broadcasting

A meno che gli array su cui state operando siano della stessa dimensione, non è possibile fare operazioni per elementi. In casi come questo, NumPy esegue il broadcasting per cercare di abbinare gli elementi. Essenzialmente, la trasmissione comporta alcuni passi:

• L’ultima dimensione di ogni array viene confrontata.
  • Se le lunghezze delle dimensioni sono uguali, o una delle dimensioni è di lunghezza 1, allora continuiamo.
  • Se le lunghezze delle dimensioni non sono uguali, e nessuna delle dimensioni ha lunghezza 1, allora c’è un errore.
• Continuiamo a controllare le dimensioni finché l’array più corto non ha più dimensioni.

Per esempio, le seguenti due forme sono compatibili:

A: (50,3)B (3,)

Questo perché la lunghezza della dimensione finale dell’array A è 3, e la lunghezza della dimensione finale dell’array B è 3. Sono uguali, quindi quella dimensione va bene. La matrice B è quindi senza elementi, quindi siamo a posto, e le matrici sono compatibili per le operazioni matematiche.

Anche le due forme seguenti sono compatibili:

A: (1,2)B (50,2)

L’ultima dimensione corrisponde, e A è di lunghezza 1 nella prima dimensione.

Queste due matrici non corrispondono:

A: (50,50)B: (49,49)

Le lunghezze delle dimensioni non sono uguali, e nessuna delle due matrici ha una lunghezza uguale a 1.

C’è una spiegazione dettagliata della trasmissione qui, ma faremo alcuni esempi per illustrare il principio:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

L’esempio precedente non funziona perché le due matrici non hanno una dimensione finale corrispondente. Ecco un esempio in cui l’ultima dimensione corrisponde:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Come potete vedere, array_two è stato trasmesso su ogni riga di array_one. Ecco un esempio con i nostri dati wines:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Gli elementi di rand_array sono trasmessi su ogni riga di wines, così la prima colonna di wines ha il primo valore in rand_array aggiunto ad essa, e così via.

Metodi Array di NumPy

In aggiunta alle comuni operazioni matematiche, NumPy ha anche diversi metodi che puoi usare per calcoli più complessi sugli array. Un esempio di questo è il metodo numpy.ndarray.sum. Questo trova la somma di tutti gli elementi di un array per default:

wines.sum()

9012.0

Il totale di tutte le nostre valutazioni di qualità è 154.1788. Possiamo passare l’argomento della parola chiave axis nel metodo sum per trovare le somme su un asse. Se chiamiamo sum attraverso la matrice wines e passiamo axis=0, troveremo le somme sul primo asse della matrice. Questo ci darà la somma di tutti i valori in ogni colonna. Può sembrare che le somme sul primo asse ci diano la somma di ogni colonna, ma un modo di pensare a questo è che l’asse specificato è quello che “va via”. Quindi, se specifichiamo axis=0, vogliamo che le righe vadano via, e vogliamo trovare le somme per ciascuno degli assi rimanenti attraverso ogni riga:

wines.sum(axis=0)

array()

Possiamo verificare che abbiamo fatto la somma correttamente controllando la forma. La forma dovrebbe essere 12, corrispondente al numero di colonne:

wines.sum(axis=0).shape

(12,)

Se passiamo in axis=1, troveremo le somme sul secondo asse dell’array. Questo ci darà la somma di ogni riga:

wines.sum(axis=1)

array()

Ci sono molti altri metodi che si comportano come il metodo sum, inclusi:

• numpy.ndarray.mean – trova la media di un array.
• numpy.ndarray.std – trova la deviazione standard di un array.
• numpy.ndarray.min – trova il valore minimo in un array.
• numpy.ndarray.max – trova il valore massimo in un array.

Puoi trovare una lista completa dei metodi di array qui.

NumPy Array Comparisons

NumPy rende possibile verificare se le righe corrispondono a certi valori utilizzando operazioni di confronto matematico come <, >, >=, <= e ==. Per esempio, se vogliamo vedere quali vini hanno una qualità superiore a 5, possiamo fare così:

wines > 5

array(, dtype=bool)

Otteniamo un array booleano che ci dice quali vini hanno una qualità superiore a 5. Possiamo fare qualcosa di simile con gli altri operatori. Per esempio, possiamo vedere se qualche vino ha una valutazione di qualità uguale a 10:

wines == 10

array(, dtype=bool)

Subsetting

Una delle cose potenti che possiamo fare con un array booleano e un array NumPy è selezionare solo certe righe o colonne nell’array NumPy. Per esempio, il codice seguente selezionerà solo le righe in wines dove la qualità è superiore a 7:

high_quality = wines > 7wines

array(,,])

Selezioniamo solo le righe dove high_quality contiene un valore True, e tutte le colonne. Questo sottoinsieme rende semplice filtrare gli array per determinati criteri. Per esempio, possiamo cercare vini con molto alcol e di alta qualità. Per specificare condizioni multiple, dobbiamo mettere ogni condizione tra parentesi, e separare le condizioni con un’ampolla (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Possiamo combinare il subsetting e l’assegnazione per sovrascrivere certi valori in un array:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reshaping NumPy Arrays

Possiamo cambiare la forma degli array conservando tutti i loro elementi. Questo spesso può rendere più facile l’accesso agli elementi dell’array. La rimodellazione più semplice è quella di invertire gli assi, così le righe diventano colonne e viceversa. Possiamo realizzare questo con la funzione numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Possiamo utilizzare la funzione numpy.ravel per trasformare un array in una rappresentazione unidimensionale. Essenzialmente appiattirà un array in una lunga sequenza di valori:

wines.ravel()

array()

Ecco un esempio dove possiamo vedere l’ordine di numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Infine, possiamo usare la funzione numpy.reshape per rimodellare un array in una certa forma da noi specificata. Il codice seguente trasformerà la seconda riga di wines in un array bidimensionale con 2 righe e 6 colonne:

wines.reshape((2,6))

array(,])

Combinare gli array NumPy

Con NumPy, è molto comune combinare più array in un singolo array unificato. Possiamo usare numpy.vstack per impilare verticalmente più array. Pensatelo come se gli elementi del secondo array fossero aggiunti come nuove righe al primo array. Possiamo leggere il dataset winequality-white.csv che contiene informazioni sulla qualità dei vini bianchi, poi combinarlo con il nostro dataset esistente, wines, che contiene informazioni sui vini rossi.

Nel codice seguente, noi:

• Leggiamo in winequality-white.csv.
• Visualizziamo la forma di white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Come potete vedere, abbiamo attributi per 4898 vini. Ora che abbiamo i dati dei vini bianchi, possiamo combinare tutti i dati dei vini.

Nel codice seguente, noi:

• Utilizziamo la funzione vstack per combinare wines e white_wines.
• Visualizza la forma del risultato.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Come potete vedere, il risultato ha 6497 righe, che è la somma del numero di righe in wines e il numero di righe in red_wines.

Se vogliamo combinare gli array orizzontalmente, dove il numero di righe rimane costante, ma le colonne sono unite, allora possiamo usare la funzione numpy.hstack. Gli array che combiniamo devono avere lo stesso numero di righe perché questo funzioni.

Infine, possiamo usare numpy.concatenate come una versione generale di hstack e vstack. Se vogliamo concatenare due array, li passiamo in concatenate, poi specifichiamo l’argomento della parola chiave axis che vogliamo concatenare lungo. Concatenare lungo il primo asse è simile a vstack, e concatenare lungo il secondo asse è simile a hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Se sei interessato ad imparare di più su NumPy, guarda il nostro corso interattivo su NumPy e Pandas. Puoi registrarti e fare le prime missioni gratuitamente.

Potresti anche portare le tue competenze su NumPy al livello successivo con il nostro cheat sheet gratuito su NumPy!

Lettura successiva

Ora dovresti avere una buona conoscenza di NumPy, e come applicarlo ad un set di dati.

Se vuoi approfondire, ecco alcune risorse che possono essere utili:

• NumPy Quickstart – ha buoni esempi di codice e copre le funzionalità di base di NumPy.
• Python NumPy Tutorial – un ottimo tutorial su NumPy e altre librerie Python.
• Visual NumPy Introduction – una guida che usa il gioco della vita per illustrare i concetti di NumPy.

Nel nostro prossimo tutorial, ci immergiamo di più in Pandas, una libreria che si basa su NumPy e rende l’analisi dei dati ancora più facile. Risolve due dei maggiori punti dolenti che sono i seguenti:

• Non puoi mescolare più tipi di dati in un array.
• Devi ricordare che tipo di dati contiene ogni colonna.