DataFrame in Pandas: ma­ni­po­la­zio­ne delle tabelle in modo rapido e chiaro in Python

Il DataFrame in Pandas è una struttura dati per Python, uti­liz­za­bi­le per creare e ma­ni­po­la­re le tabelle. In questo articolo ti spie­ghia­mo la sintassi di questa struttura dati, oltre ai relativi metodi e alle sue proprietà prin­ci­pa­li.

Come fun­zio­na­no i DataFrame in Pandas?

I DataFrame di Pandas sono l’elemento centrale della libreria Pandas di Python e con­sen­to­no di ana­liz­za­re i dati in modo ef­fi­cien­te e fles­si­bi­le in Python. Un DataFrame di Pandas è una struttura di dati bi­di­men­sio­na­le e tabellare con­te­nen­te righe numerate e colonne eti­chet­ta­te. Questa struttura ti permette di or­ga­niz­za­re i dati in un formato facile da com­pren­de­re e ma­ni­po­la­re, simile ai programmi per fogli di calcolo come Excel o Li­breOf­fi­ce. Ogni colonna di un DataFrame può contenere diversi tipi di dati Python, il che significa che in un DataFrame è possibile salvare dati ete­ro­ge­nei, ad esempio valori numerici, sequenze di caratteri e booleani, in un’unica tabella.

Struttura dei DataFrame in Pandas

Un DataFrame è co­sti­tui­to da tre com­po­nen­ti prin­ci­pa­li: i dati stessi, gli indici di riga e i nomi di colonna. L’indice di riga (o sem­pli­ce­men­te indice) funge da iden­ti­fi­ca­to­re univoco per ogni riga. Per im­po­sta­zio­ne pre­de­fi­ni­ta, le righe sono in­di­ciz­za­te con valori numerici, che però possono essere so­sti­tui­ti da stringhe. Tieni presente che i DataFrame in Pandas hanno in­di­ciz­za­zio­ne null, ossia gli indici partono da 0.

Close

Come uti­liz­za­re i DataFrame in Pandas

I DataFrame in Pandas offrono svariate tecniche e metodi che per­met­to­no di mo­di­fi­ca­re, ana­liz­za­re e vi­sua­liz­za­re i dati in modo ef­fi­cien­te. Nei paragrafi seguenti imparerai alcuni dei concetti e dei metodi più im­por­tan­ti per la ma­ni­po­la­zio­ne dei dati con i DataFrame in Pandas.

Creazione di DataFrame in Pandas

Se hai già me­mo­riz­za­to i dati de­si­de­ra­ti in una lista di Python o in un di­zio­na­rio in Python, puoi creare fa­cil­men­te un DataFrame partendo da tali dati. A questo scopo non devi far altro che tra­sfe­ri­re la struttura di dati esistente, come argomento, al co­strut­to­re DataFrame pandas.DataFrame([Dati]). Tuttavia, il modo in cui Pandas in­ter­pre­ta i tuoi dati dipende dalla struttura di dati che trasmetti al co­strut­to­re. Di seguito ti mostriamo un esempio di come creare un DataFrame in Pandas partendo da un elenco in Python:

import pandas
elenco = ["Alberto", "Beatrice", "Carla", "Diego", "Elisabetta", "Franco"]
df = pandas.DataFrame(elenco)
print(df)
# Risultato:
#            0
# 0     Alberto
# 1      Beatrice
# 2     Carla
# 3    Diego
# 4    Elisabetta
# 5  Franco

Come puoi notare nell’esempio sopra, con elenchi semplici è possibile creare solo DataFrame con una singola colonna non eti­chet­ta­ta. Per questo motivo è con­si­glia­bi­le creare i DataFrame partendo da dizionari che con­ten­go­no gli elenchi. In questo modo, le chiavi vengono in­ter­pre­ta­te come nomi delle colonne e gli elenchi come i dati a esse correlati. Per chiarire il fun­zio­na­men­to, osserva l’esempio seguente:

import pandas
dati = {
    'Nome': ['Arturo', 'Bruno', 'Cristiano'],
    'Età': [34, 30, 55],
    'Stipendio': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(dati)
print(df)
# Risultato:
#         Nome  Età   Stipendio
# 0     Arturo     34  75000.0
# 1      Bruno     30  60000.5
# 2  Cristiano     55  90000.3

Con questo metodo il DataFrame ac­qui­si­sce im­me­dia­ta­men­te il formato e i titoli che desideri. Se invece non vuoi ap­pog­giar­ti alle strutture di dati integrate in Python, puoi anche caricare i tuoi dati da una fonte esterna, ad esempio da un file CSV o da un database SQL. A tal fine è suf­fi­cien­te ri­chia­ma­re l’apposita funzione di Pandas:

import pandas
import sqlalchemy
# DataFrame da CSV:
csv = pandas.read_csv("file-csv/dati.csv")
# DataFrame da SQL:
engine = create_engine('postgresql://nomeutente:password@localhost:5432/mio_database')
sql = pandas.read_sql_query('SELECT * FROM tabella', engine)

I DataFrame csv e sql dell’esempio pre­ce­den­te con­ten­go­no ora tutti i dati del file dati.csv e della tabella SQL tabella. In più, è possibile spe­ci­fi­ca­re ulteriori dettagli durante la creazione di un DataFrame partendo da una fonte esterna, ad esempio sce­glien­do se includere o meno gli indici numerici nel DataFrame. Per ulteriori in­for­ma­zio­ni sugli argomenti ag­giun­ti­vi delle due funzioni consulta la pagina ufficiale per i DataFrame in Pandas.

DataFrame in Pandas: vi­sua­liz­za­zio­ne dei dati

Con i DataFrame in Pandas puoi vi­sua­liz­za­re non soltanto l’intera tabella, ma anche singole righe e colonne. In più, puoi scegliere le righe e le colonne da vi­sua­liz­za­re. L’esempio seguente mostra come vi­sua­liz­za­re righe o colonne singole o multiple:

# Mostra la riga 0
print(df.loc[0])
# Mostra righe da 3 a 6
print(df.loc[3:6])
# Mostra righe da 3 e 6
print(df.loc[[3, 6]])
# Mostra colonna “Professione”
print(df["Professione"])
# Mostra colonne “Professione” e “Età”
print(df[["Professione", "Età"]])
# Selezione di più righe e colonne
print(df.loc[[3, 6], ['Professione', 'Età']])

Come puoi notare nell’esempio, facendo ri­fe­ri­men­to a una colonna si utilizza soltanto il nome della colonna stessa tra parentesi semplici, come nei dizionari Python. Al contrario, quando si fa ri­fe­ri­men­to a una riga si utilizza sempre l’attributo loc. Con loc è possibile anche usare con­di­zio­ni logiche per filtrare i dati. Questa al­ter­na­ti­va è uti­liz­za­ta nel seguente blocco di codice, che stampa solo le righe in cui il valore “Età” è maggiore di 30:

print(df.loc[df['Età'] > 30])

Inoltre, è possibile uti­liz­za­re l’attributo iloc per se­le­zio­na­re righe e colonne in base alla loro posizione nel DataFrame. In questo modo, ad esempio, puoi vi­sua­liz­za­re la cella nella terza riga della quarta colonna:

print(df.iloc[3, 4])
# Risultato:
# Torino
print(df.iloc[[3, 4, 6], 4])
# Risultato:
# 3    Torino
# 4    Milano
# 6    Venezia

DataFrame in Pandas: ite­ra­zio­ne sulle righe

Quando si ma­ni­po­la­no i dati in Python, spesso è ne­ces­sa­rio eseguire ite­ra­zio­ni sulle righe di un DataFrame in Pandas, ad esempio per applicare la stessa ope­ra­zio­ne su tutti i dati. A tal fine, Pandas offre due diversi metodi per DataFrame: itertuples() e iterrows(). Entrambi i metodi pre­sen­ta­no vantaggi e svantaggi in termini di pre­sta­zio­ni e facilità d’uso.

Il metodo iterrows() re­sti­tui­sce una tupla composta da indice e serie per ciascuna riga del DataFrame. Una serie è un’altra struttura dati di Pandas o NumPy che è molto simile a una lista di Python in molti aspetti, ma che offre pre­sta­zio­ni migliori. È possibile accedere ai singoli elementi della serie uti­liz­zan­do il nome della colonna, il che sem­pli­fi­ca molto la gestione dei dati.

Sebbene le serie di Pandas siano di gran lunga più ef­fi­cien­ti delle liste di Python, questa struttura di dati presenta comunque un notevole overhead in termini di pre­sta­zio­ni. Per questo motivo è par­ti­co­lar­men­te con­si­glia­to il metodo itertuples() per i DataFrame molto grandi. A dif­fe­ren­za di iterrows(), il metodo itertuples() re­sti­tui­sce l’intera riga compreso l’indice sotto forma di tuple, che offrono pre­sta­zio­ni molto superiori rispetto alle serie. Le tuple per­met­to­no di accedere ai singoli elementi uti­liz­zan­do un punto, come nel caso degli attributi di un oggetto.

Un’altra im­por­tan­te dif­fe­ren­za tra serie e tuple è che le tuple non sono mutabili. Pertanto, se desideri eseguire un’ite­ra­zio­ne su un DataFrame e mo­di­fi­ca­re i valori uti­liz­zan­do itertuples(), devi fare ri­fe­ri­men­to al DataFrame usando l’attributo at e l’indice della tupla. Questo attributo funziona in modo molto simile a loc. L’esempio seguente mostra le dif­fe­ren­ze tra iterrows() e itertuples():

import pandas
df = pandas.DataFrame({
    'Nome': ['Alice', 'Bruno', 'Carlo],
    'Età': [25, 30, 35],
    'Stipendio': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Stipendio'] += 1000
        print(f"Index: {index}, Età: {row['Età']}, Stipendio: {row['Stipendio']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Stipendio'] += 1000 # Modifica valore tramite at[] direttamente nel DataFrame
        print(f"Index: {tup.Index}, Età: {tup.Età}, Stipendio: {df.loc[tup.Index, 'Stipendio']}")
# Entrambi i cicli danno lo stesso risultato