5 consigli per scrivere codice Pandas idiomatico

Ovviamente, questo tutorial non è affatto esaustivo; Il pacchetto Pandas è molto ricco e, senza dubbio, esistono altri modi per migliorare il tuo codice Pandas affinché diventi più idiomatico.

Non aspettiamo oltre e iniziamo!

# If you're working with a notebook, don't forget to use Matplotlib magic! 
%matplotlib inline

# Import pandas under the alias pd import pandas as pd # Import seaborn under the alias sns import seaborn as sns # Set the Seaborn theme if desired sns.set_style('darkgrid')

# Import Times Higher Education World University Rankings data
times_df = pd.read_csv('data/timesData.csv', thousands=",")

# Import Academic Ranking of World Universities data
shanghai_df = pd.read_csv('data/shanghaiData.csv')

I nostri consigli per codice Pandas idiomatico

1. Indicizzazione

Per cominciare, scrivere codice Pandas più idiomatico significa sfruttare la potenza dell’indicizzazione. Indicizzare vuol dire selezionare sottoinsiemi dal tuo DataFrame.

Quando inizi a usare Pandas, potresti aver bisogno di un po’ di tempo per abituarti al funzionamento degli indici. Infatti, se hai già lavorato con le liste (Python), potresti già conoscere l’uso delle parentesi quadre [] in combinazione con i due punti : per selezionare elementi. Questo metodo funziona sui DataFrame.

In aggiunta, ci sono altri due modi, più idiomatici, per selezionare un sottoinsieme di DataFrame: iloc e loc:

• loc è basato sulle etichette. Significa che se scrivi loc[2], stai cercando i valori del tuo DataFrame con indice etichettato 2.
• iloc è basato sulla posizione. Significa che se scrivi iloc[2], stai cercando i valori del tuo DataFrame che si trovano alla posizione di indice 2.

Provalo nel blocco DataCamp Light qui sotto digitando times_df.loc[2] e times_df.iloc[2] nella console IPython per vedere la differenza. Poi prova a risolvere l’esercizio qui sotto con l’aiuto di loc, iloc e delle tradizionali parentesi quadre!

Ovviamente, l’esplorazione può andare ben oltre il semplice sottoinsieme o la selezione di righe e colonne dei dati. Le cose diventano molto interessanti quando combini loc e iloc con, per esempio, array booleani.

Vedi che questo va un po’ oltre la selezione dei dati in base a colonne o indici; È un po’ come interrogare i tuoi dati!

loc e iloc sono ottimi per indicizzare i dati, ma fai attenzione quando inizi a usare due coppie di parentesi quadre una dopo l’altra! Pandas potrebbe restituire una copia di una vista e, in tali casi, non sapresti più con cosa stai lavorando! Quindi pensaci due volte se stai usando due coppie di parentesi quadre in combinazione con loc o iloc.

Nota anche che, per interrogare i dati, Pandas mette a disposizione la funzione query() che puoi usare per ispezionarli rapidamente (disponibile dalla versione 0.13). Per esempio, puoi comporre una query per vedere quali università hanno un total_score leggermente inferiore a 50:

Ovviamente, ci sono molte altre possibilità quando si tratta di interrogare i tuoi dati! Perché non provare a inventare qualche query e testarle nella console IPython del blocco DataCamp Light qui sopra?

Se ti manca l’ispirazione, prova query che restituiscono le università con primo posto nel ranking nazionale e nel ranking mondiale. Inoltre, puoi interrogare i numeri degli alumni delle università.

Non sai come comporre le query? Dai un’occhiata ad alcuni esempi qui sotto:

shanghai_df.query("national_rank == 1 and world_rank == 1")
shanghai_df.query("alumni < 20")

2. Method chaining

Il method chaining è qualcosa di tipico di Pandas, ma quando inizi a usare il pacchetto Python per la manipolazione dei dati, potrebbe non essere immediato capire come funziona esattamente. In pratica, si tratta di chiamare metodi su un oggetto uno dopo l’altro.

In questa sezione, approfondirai il method chaining creando pipeline di dati con pipe().

Come avrai già notato, i dataset sono piuttosto diversi. Ecco alcune differenze:

• Il dataset Times ha 14 colonne mentre quello di Shanghai ne ha 11
• Il dataset Times ha 2603 righe mentre quello di Shanghai ne ha 4897
• Una colonna importante mancante nel dataset Shanghai è il paese dell’università. Se necessario, recupererai questa informazione dal dataset Times più avanti.

Quindi, per usare entrambi i DataFrame, dovremo selezionare solo le colonne comuni. Si spera che queste colonne comuni abbiano contenuti simili.

Le colonne comuni sono quindi:

• total_score: punteggio usato per determinare il rank. Come indicato nella pagina di descrizione su Kaggle, contiene range di rank (cioè compresi tra due valori) e rank uguali (c’è un segno = davanti)
• university_name: nome dell’università
• world_rank: posizionamento dell’università
• year: anno a cui si riferisce la classifica

Per concatenare entrambi i dati, dobbiamo prima fare un po’ di pulizia. Quindi applica ora l’intera pipeline per ripulire i dati:

Come avrai probabilmente notato, uso molto il metodo .pipe in questo tutorial. Se provieni dal mondo R, probabilmente ti è (in qualche modo) familiare.

È un comodo metodo nuovo di Pandas (dalla versione 0.16.2) che ti permette di concatenare operazioni eliminando così la necessità di DataFrame intermedi. Il tuo codice diventa più leggibile.

Infatti, senza questo operatore, invece di scrivere df.pipe(f).pipe(g).pipe(h) scriveresti: h(g(f(df))). Questo diventa più difficile da seguire quando il numero di funzioni annidate cresce.

Per saperne di più sull’argomento, consiglio vivamente di leggere questo post del blog.

Ora che entrambi i DataFrame sono puliti, possiamo concatenarli in un unico DataFrame. Inoltre, non dimenticare di ripulire i dati mancanti:

Poiché hai circa il 38% di dati mancanti nella colonna total_score, è meglio eliminare questa colonna con il metodo .drop.

3. Ottimizzazione della memoria

Un terzo modo per rendere il tuo codice Pandas più “idiomatico” – che in questo caso equivale più a “performante” – è ottimizzando l’uso della memoria. Soprattutto quando inizi a creare pipeline di dati usando il method chaining, vedrai che la memoria può iniziare a giocare un ruolo importante nella velocità di esecuzione. Vedrai di più su tutto questo qui.

Probabilmente è eccessivo per questo piccolo dataset, ma spesso è una buona pratica convertire alcune colonne in tipi specifici per ottimizzare l’uso della memoria. Per iniziare, vediamo quanta memoria è allocata per ranking_df usando il metodo .info.

Il risultato della prima riga di codice ci dice che i dati occupano 144 KB. Tuttavia, ispezionando gli argomenti del metodo .info, si scopre che ne esiste uno opzionale, memory_usage, impostato su None per impostazione predefinita. Cosa succede quando imposti l’argomento memory_usage su deep?

La nuova impronta di memoria è 6 – per la precisione 5,6 – volte più grande della tua risposta iniziale.

Cosa è successo?

La differenza nella stima della memoria deriva dal fatto che, senza il flag “deep” attivato, Pandas non stima il consumo di memoria per il dtype object. Questo tipo (Python) occupa più spazio rispetto ad altri dtypes ottimizzati di numpy. Per questo è consigliato convertire i tipi object in tipi più appropriati (ad esempio category quando si lavora con dati categoriali).

Facciamolo!

def memory_change(input_df, column, dtype):
    df = input_df.copy()
    old = round(df[column].memory_usage(deep=True) / 1024, 2) # In KB
    new = round(df[column].astype(dtype).memory_usage(deep=True) / 1024, 2)# In KB
    change = round(100 * (old - new) / (old), 2)
    report = ("The inital memory footprint for {column} is: {old}KB.\n" 
              "The casted {column} now takes: {new}KB.\n"
              "A change of {change} %.").format(**locals())
    return report

print(memory_change(ranking_df,'world_rank', 'int16'))
print(memory_change(ranking_df,'university_name', 'category'))
print(memory_change(ranking_df,'name', 'category'))

Ora che sai che, cambiando per esempio world_rank in int16, la tua memoria verrà usata in modo più efficiente, è il momento di applicare davvero queste modifiche. Puoi usare la funzione astype() per farlo. Concludi ricontrollando come appare ora l’uso della memoria:

Molto meglio. Puoi ottimizzare ulteriormente convertendo la colonna year a int32.

4. GroupBy

Ora che abbiamo un dataset ben formato (cioè in uno stato tidy) con un’impronta di memoria ottimizzata, l’analisi dei dati può iniziare.

Ci sono alcune domande a cui potresti voler rispondere:

• Quali sono le 5 università migliori secondo ciascun sistema di ranking nel corso degli anni?
• Quanto differiscono queste classifiche per ogni anno?

Scopriamolo affrontando la prima domanda facendo uso dei suggerimenti Pandas più idiomatici che hai già visto nelle sezioni precedenti!

Prima di iniziare, nota che “Massachusetts Institute of Technology (MIT)” e “Massachusetts Institute of Technology” sono due record diversi della stessa università. Quindi, cambia il primo nome con il secondo.

Nota che in casi come questi la funzione loc, che hai visto in precedenza in questo tutorial, torna particolarmente utile!

Per trovare le 5 (più in generale n) università migliori nel corso degli anni, per ciascun sistema di ranking, ecco come fare in pseudo-codice:

• Per ogni anno (nella colonna year) e per ogni sistema di ranking (nella colonna name):
• Seleziona il sottoinsieme di dati per l’anno e il sistema di ranking dati
• Seleziona le prime 5 università e salvale in una lista
• Salva il risultato in un dizionario con (year, name) come chiave e la lista delle università (in ordine decrescente) come valore

Applichiamolo.

Ora che abbiamo questo dizionario di ranking, vediamo di quanto (in percentuale) i due metodi di ranking differiscono nel corso degli anni: i due sono simili al 100% come insiemi se le 5 università selezionate sono le stesse, anche se l’ordine non coincide.

Come avrai notato, è stato laborioso. Esiste un modo migliore, più idiomatico in Pandas?

Certo! Per prima cosa, filtra il DataFrame di ranking per tenere solo le prime 5 università per ciascun anno e metodo di ranking. Controlla anche il risultato con l’aiuto della funzione head():

Ora che hai il DataFrame corretto con cui lavorare, usiamo il metodo .groupby per confrontare entrambi i metodi di ranking usando la similarità di insiemi definita sopra.

Ottieni gli stessi risultati di prima con meno fatica.

5. Visualizzazione

Ora che hai effettuato un’analisi iniziale dei tuoi dataset, è anche il momento di esplorare visivamente i dati. Scrivere codice Pandas più idiomatico significa anche sfruttare l’integrazione di Pandas con il pacchetto Matplotlib per i grafici. Per questo, realizzerai ottimi plot in pochissimo tempo!

Per questa sezione, tornerai ai dataset times_df e shanghai_df per creare alcune visualizzazioni di base con Matplotlib e Seaborn.

Il plot sopra mostra subito che ci sono alcuni valori 0 per la colonna alumni. È qualcosa da tenere sicuramente in considerazione quando esplori i dati: con l’aiuto del data profiling, sarai in grado di vedere questi 0 e gestirli. Se vuoi saperne di più, dai un’occhiata al tutorial sul Data Profiling di DataCamp.

Oppure, se hai valori che non hanno posto nel tuo dataset, puoi semplicemente sostituirli con NaN e poi rimuovere tutti i valori NaN delle colonne che renderebbero più difficile la visualizzazione. Nota che è solo un modo rapido per aggiustare i dati e che probabilmente serve un passaggio di data profiling più approfondito per migliorare davvero la qualità, perché nel grafico sotto vedi ancora valori 0 per la colonna num_students:

Ovviamente, non devi limitarti a Matplotlib per visualizzare i dati. Ci sono anche altre librerie che ti permettono di visualizzare rapidamente i dati, come Seaborn.

Lo strumento di plotting Seaborn è usato principalmente per creare grafici statistici visivamente gradevoli (come indicato sul sito ufficiale). In effetti, prima della versione 2.0 di Matplotlib, creare grafici belli era laborioso (sebbene possibile).

La combinazione di Pandas con Seaborn ti permette anche di iterare rapidamente sui dati tramite visualizzazioni.

Esploriamo qualche esempio!

Guarda il seguente grafico, in cui conti il numero di volte in cui un determinato paese compare nei dati, prendi le prime dieci osservazioni e ti assicuri di ordinare i conteggi dal valore più alto al più basso quando crei il barplot:

Poi, puoi proseguire e plottare questi paesi e i loro punteggi medi:

I tuoi grafici possono diventare anche piuttosto complessi. Guarda il seguente pairplot, pensato per mostrarti più chiaramente le relazioni a coppie in un dataset:

import numpy as np

np.seterr(invalid='ignore')

sns.pairplot(times_df, hue='country')

plt.show()

Allo stesso modo, puoi dare un’occhiata a questa combinazione di FacetGrid e regplot, che ti dà qualche insight sull’evoluzione del total_score nel corso degli anni per i 5 paesi principali:

Infine, anche un grafico di correlazione può tornare utile quando esplori i dati. Puoi usare la funzione heatmap() di Seaborn per farlo:

Potresti continuare all’infinito con queste visualizzazioni, quindi forse è meglio fermarsi per ora :)