Le 10 principali funzioni di Pandas che ogni principiante dovrebbe conoscere

Pandas è la libreria preferita dagli analisti di dati e dai programmatori Python che si avventurano nel mondo della manipolazione e dell'analisi dei dati. La sua sintassi intuitiva e le sue potenti strutture dati rendono la gestione di vasti insiemi di dati non solo gestibile ma anche efficiente. Che si tratti di importare file CSV, pulire insiemi di dati disordinati o analizzare le tendenze dei dati, Pandas ha gli strumenti necessari.

Se avete appena iniziato il vostro percorso di apprendimento di Pandas, questo post vi introdurrà a 10 funzioni e metodi essenziali che ogni principiante dovrebbe conoscere. Queste funzioni vi aiuteranno a caricare, ispezionare, pulire e analizzare i dati con facilità.
Ecco una rapida panoramica di ogni metodo e di ciò che fa:

• read_csv(): Carica i dati da un file CSV in un DataFrame di Pandas.
• testa(): Visualizza le prime righe del DataFrame.
• info(): Fornisce un riepilogo conciso del DataFrame, compresi i tipi di colonna e i valori mancanti.
• descrivere(): Genera statistiche descrittive per le colonne numeriche.
• isnull(): Identifica i dati mancanti nel DataFrame.
• dropna(): Rimuove le righe o le colonne con dati mancanti.
• fillna(): Sostituisce i dati mancanti con i valori specificati.
• groupby(): Raggruppa i dati in base a una o più colonne e applica funzioni aggregate.
• ordina_valori(): Ordina il DataFrame in base a una o più colonne.
• applicare(): Applica funzioni personalizzate alle righe o alle colonne del DataFrame.

Prerequisiti

Innanzitutto, assicuratevi che Python sia installato sul vostro computer. Se non lo è, è possibile scaricarlo da questo link.
Una volta configurato Python, verificare che la libreria Pandas sia installata. Se non lo è, è possibile aggiungerla facilmente con il seguente comando:

pip installa pandas

Per i nostri esempi utilizzeremo il seguente dataset di immobili fittizi:

Le 10 principali funzioni e metodi di Pandas

1. read_csv(): Carica i dati da un file CSV in un DataFrame di Pandas.

Il primo passo nell'uso di pandas è il caricamento dei dati per prepararli all'elaborazione o all'analisi. Uno dei metodi più comuni per importare i dati in un DataFrame di pandas è la funzione read_csv().

Esempio di codice:

importare pandas come pd
# Caricare il set di dati in un DataFrame di Pandas
file_path = "real_estate_listings.csv" # Sostituire con il percorso effettivo del file

# Creare il DataFrame
df = pd.read_csv(file_path)

Per prima cosa, iniziamo a importare la libreria pandas. Utilizzando come pd è una convenzione comune tra gli sviluppatori per semplificare il codice. Per esempio, invece di scrivere pandas.read_csv()possiamo semplicemente utilizzare pd.read_csv()rendendo il codice più conciso e più facile da leggere.

Quindi, specificare il percorso del file CSV che si vuole caricare in un DataFrame di Pandas. Quindi, creare una variabile e utilizzare l'opzione leggere_csv per caricare il file nel DataFrame.

Parametri chiave:

Esaminiamo ora alcuni parametri importanti che seguono questo metodo:

• delimitatore: Specificare il delimitatore utilizzato nel file CSV (ad esempio, ,, ;, \t).

df = pd.read_csv(file_path, delimiter=',')

• indice_col: Nella nostra tabella, ogni annuncio immobiliare è identificato da un ID che si trova nella sezione "ProprietàID". Per assicurarsi che pandas utilizzi questa colonna come identificatore univoco per ogni proprietà, è possibile impostarla esplicitamente come colonna ID. Altrimenti, pandas genererà e assegnerà automaticamente i propri valori di ID a ciascun elenco.

df = pd.read_csv(file_path, index_col='PropertyID')

• usecoli: Se il file CSV contiene numerose colonne ma ne servono solo alcune, pandas consente di ottenere facilmente questo risultato utilizzando un parametro specifico.

df = pd.read_csv(file_path, usecols=['Location', 'Price', 'Bedrooms'])

2. head() e tail(): Ispezionare i dati

Ora che i dati sono stati caricati nel DataFrame, possiamo iniziare a esplorarli. Per farlo, Pandas mette a disposizione due metodi molto utili: testa() e coda(). Questi metodi sono essenziali per ispezionare rapidamente le prime o le ultime righe del set di dati.

• head(): Questo metodo mostra le prime 5 righe del dataset per impostazione predefinita. È particolarmente utile per verificare che i dati siano stati caricati correttamente e per controllarne la struttura.
• tail(): Questo metodo funziona in modo simile a head(), ma visualizza le ultime righe. È utile per esaminare la fine del set di dati, in particolare per verificare se i dati sono completi o se i record finali hanno valori mancanti.

Esempio di codice:

# Visualizzare le prime 5 righe
print(df.head())
# Visualizzare le ultime 3 righe
print(df.tail(3))

Uscita di testa():

Uscita di coda():

3. info() - Comprendere la struttura del DataFrame

La funzione info() fornisce un riassunto conciso del DataFrame. Include dettagli quali:

• Il numero di righe e colonne.
• Nomi delle colonne e relativi tipi di dati.
• Il conteggio dei valori non nulli in ogni colonna.

Questo metodo è utile per comprendere rapidamente la struttura del dataset e per individuare problemi come valori mancanti o tipi di dati errati.

Esempio di codice:

# Ottenere un riassunto conciso del DataFrame
print(df.info())

Il codice precedente produce il seguente risultato:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 7 columns):
#   Column          Non-Null Count  Dtype 
---  ------          --------------  ----- 
0   PropertyID      6 non-null      int64 
1   Location        6 non-null      object
2   Bedrooms        6 non-null      int64 
3   Bathrooms       6 non-null      int64 
4   Price           5 non-null      float64
5   SquareFootage   6 non-null      int64 
6   ListingDate     5 non-null      object
dtypes: float64(1), int64(4), object(2)
memory usage: 464.0+ bytes

4. describe(): Genera statistiche di riepilogo

Il descrivere() Il metodo fornisce un rapido riepilogo delle metriche statistiche chiave, come ad esempio media, deviazione standard, percentilie altro ancora. Per impostazione predefinita, descrivere() lavora con dati numerici ma può anche gestire dati categorici, offrendo approfondimenti personalizzati in base al tipo di dati.

Parametri chiave:

• percentili: Un elenco di numeri compresi tra 0 e 1, che specificano quali percentili restituire. Il valore predefinito è Nessuno, che restituisce il 25°, 50° e 75° percentile. Per saperne di più qui.
• includere: Un elenco di tipi di dati da includere nel sommario. È possibile specificare tipi di dati quali int, float, object (per le stringhe), ecc. Il valore predefinito è Nessuno, il che significa che tutti i tipi numerici sono inclusi.
• escludere: Un elenco di tipi di dati da escludere dal riepilogo. Questo parametro è anche Nessuno per impostazione predefinita, il che significa che nessun tipo è escluso.

Esempio di codice:

stampa(df.describe())

L'output del codice è il seguente:

       PropertyID Posizione Camere da letto ...         Prezzo Metratura Data di inserimento
conteggio 6.000000 6 6.000000... 5.000000e+00 6.000000 5
unico NaN 6 NaN ...           NaN NaN 5
top NaN New York NaN ...           NaN NaN 2023-05-15
freq NaN 1 NaN ...           NaN NaN 1
media 103.500000 NaN 3.500000... 7,800000e+05 2150,000000 NaN
std 1,870829 NaN 1,048809... 2,774887e+05 755,645419 NaN
min 101,000000 NaN 2,000000... 4,500000e+05 1400,000000 NaN
25% 102,250000 NaN 3,000000... 6.500000e+05 1725.000000 NaN
50% 103,500000 NaN 3,500000... 7,500000e+05 1900,000000 NaN
75% 104,750000 NaN 4,000000... 8.500000e+05 2375,000000 NaN
max 106,000000 NaN 5,000000... 1.200000e+06 3500.000000 NaN

Spiegazione di ogni statistica

• Conteggio: Il numero di voci non mancanti per ogni colonna.
  • Esempio: contare = 6 per Camere da letto, indicando che tutte le righe hanno dati validi.
• Media: Il valore medio della colonna.
  • Esempio: media = 3,5 per Camere da letto, indicando una media di 3,5 camere da letto per proprietà.
• Std: La deviazione standard, che mostra l'ampiezza dei valori rispetto alla media.
  • Esempio: std = 1,048809 per Camere da lettoIl che significa che c'è una moderata variazione nel numero di camere da letto.
• Min/Max: I valori più piccoli e più grandi.
  • Esempio: min = 2 e max = 5 per Camere da letto.
• 25%, 50%, 75% (quartili): Rappresentano la diffusione dei dati:
  • 25%: Il valore al di sotto del quale cade il 25% dei dati (primo quartile).
  • 50%: Il valore mediano.
  • 75%: Il valore al di sotto del quale cade il 75% dei dati (terzo quartile).

5. isnull(): Identificare i dati mancanti

Il isnull() aiuta a identificare i dati mancanti in un DataFrame. Restituisce un DataFrame della stessa forma dell'originale, con Vero dove mancano i dati NaN e Falso altrimenti. Viene comunemente utilizzata con altre funzioni come somma() per contare i valori mancanti nelle colonne o nelle righe.

Esempio di codice:

# Identificare i valorimancanti
print(df.isnull())
# Conta i valori mancanti per ogni colonna
print(df.isnull().sum())

df.isnull() Uscita:

  ProprietàID  Posizione  Camere da letto  Bagni  Prezzo  Metratura  Data dell'annuncio
0       Falso     Falso     Falso      Falso  Falso          Falso        Falso
1       Falso     Falso     Falso      Falso  Falso          Falso        Falso
2       Falso     Falso     Falso      Falso   Vero          Falso        Falso
3       Falso     Falso     Falso      Falso  Falso          Falso         Vero
4       Falso     Falso     Falso      Falso  Falso          Falso        Falso
5       Falso     Falso     Falso      Falso  Falso          Falso        Falso

df.isnull().sum() Uscita:

PropertyID 0
Posizione 0
Camere da letto 0
Bagni 0
Prezzo 1
Metratura 0
Data di inserimento 1
dtype: int64

6. dropna(): Rimuovere i dati mancanti

Il dropna() la funzione rimuove file o colonne con dati mancanti NaN dal DataFrame. Per impostazione predefinita, rimuove le righe con qualsiasi valore mancante. È possibile personalizzare il comportamento per rimuovere solo le colonne o per eliminare le righe/colonne in cui mancano tutti i valori o un sottoinsieme specifico di valori.

Esempio di codice:

# Eliminare le righe con i valori mancanti 
df_dropped_rows = df.dropna()
print(df_dropped_rows)

# Eliminare le colonne con i valori mancanti 
df_dropped_columns = df.dropna(axis=1)
print(df_colonne_scartate)

Questo è l'aspetto del DataFrame dopo aver rimosso tutti gli elementi file contenente NaN valori:

Ecco il dataframe con colonne contenente NaN valori rimossi.

7. fillna(): Sostituire i dati mancanti

Il fillna() la funzione sostituisce i dati mancanti NaN con i valori specificati. Il pandas dropna() gestisce e rimuove in modo efficiente i valori nulli da un DataFrame, mentre il metodo fillna() Il metodo offre una soluzione flessibile per sostituire NaN con un valore specifico a scelta. Questo metodo offre un approccio flessibile alla gestione dei dati mancanti, consentendo di riempire gli spazi vuoti utilizzando un valore fisso, il valore media, mediano, modalitào altre statistiche calcolate.

Esempio di codice:

# Riempire i valori mancanti nella colonna 'Prezzo' con il prezzo medio df['Prezzo'] = 
df['Prezzo'].fillna(df['Prezzo'].media()) 
print(df)

L'output del codice dimostra che l'opzione NaN è stato sostituito con il prezzo medio.

Il Data di inserimento contiene anche una colonna NaN valore. Invece di eseguire un calcolo, si può semplicemente usare un segnaposto come "sconosciuto. Ecco come fare;

# Riempire i valori mancanti nella colonna 'ListingDate' con un segnaposto
df['ListingDate'] = df['ListingDate'].fillna('Unknown')
print(df)

Il Dataframe si presenta ora come segue:

8. groupby(): Raggruppare e aggregare i dati

La funzione groupby() di Pandas è uno strumento versatile e potente per dividere un DataFrame in gruppi basati su una o più colonne, consentendo un'efficiente analisi e aggregazione dei dati.
Funziona secondo il principio split-apply-combine:
prima i dati vengono divisi in gruppi;
poi viene applicata una funzione specifica a ciascun gruppo;
infine i risultati vengono combinati in un nuovo DataFrame.
Questo approccio snello semplifica le complesse operazioni di manipolazione dei dati e migliora l'efficienza analitica.

Esempio di codice:

Ad esempio, è possibile calcolare il prezzo medio degli immobili per località o contare il numero di annunci per categoria di camera da letto.

# Raggruppare per "località" e calcolare il prezzo medio
avg_price_by_location = df.groupby('Location')['Price'].mean()
print(avg_price_by_location)
# Raggruppare per 'Camere da letto' e calcolare la metratura totale
total_sqft_by_bedrooms = df.groupby('Bedrooms')['SquareFootage'].sum()
print(total_sqft_by_bedrooms)
# Raggruppare per più colonne e calcolare il conteggio
count_by_location_bedrooms = df.groupby(['Location', 'Bedrooms']).size()
print(count_by_location_bedrooms)

Prezzo medio per località:

Posizione
Chicago 650000.0
Houston 450000.0
Los Angeles NaN
Miami 1200000.0
New York 750000.0
San Francisco 850000.0
Nome: Prezzo, tipo: float64

Metratura totale per camere da letto:

Camere da letto
2    1400
3    3500
4    4500
5    3500

Conteggio per posizione e camere da letto:

Posizione Camere da letto
Chicago 3 1
Houston 4 1
Los Angeles 4 1
Miami 5 1
New York 3 1
San Francisco 2 1
tipo: int64

9. sort_values(): Ordinamento dei dati

La funzione sort_values() serve per ordinare il DataFrame in base a una o più colonne, in ordine crescente o decrescente. L'ordinamento è essenziale per classificare i dati, identificare gli estremi (ad esempio, gli immobili con i prezzi più alti) o semplicemente organizzare il set di dati per una migliore leggibilità. È possibile ordinare in base a colonne numeriche, categoriche o di data e ora.

Esempio di codice:

# Ordina per 'Prezzo' in ordine decrescente
df_sorted_by_price = df.sort_values(by='Price', ascending=False)
print(df_sorted_by_price)
# Ordina per 'Località' in ordine crescente
df_sorted_by_location = df.sort_values(by='Location')
print(df_sorted_by_location)
# Ordina per più colonne: prima per 'Camere da letto' (ascendente) e poi per 'Prezzo' (discendente)
df_sorted_by_bedrooms_price = df.sort_values(by=['Bedrooms', 'Price'], ascending=[True, False])
print(df_sorted_by_bedrooms_price)

Ordina per prezzo (decrescente):

  PropertyID Posizione Camere da letto ...      Prezzo Metratura Data dell'annuncio
4 105 Miami 5... 1200000.0 3500 2023-03-22
1 102 San Francisco 2...  850000.0 1400 2023-06-01
0 101 New York 3...  750000.0 1800 2023-05-15
3 104 Chicago 3...  650000,0 1700 NaN
5 106 Houston 4...  450000.0 2000 2023-07-01
2 103 Los Angeles 4...        NaN 2500 2023-04-10

Ordina per posizione (crescente):

[6 righe x 7 colonne]
  PropertyID Posizione Camere da letto ...      Prezzo Metratura Data dell'annuncio
3  104  Chicago  3 . ..   650000.0  1700  NaN
5  106  Houston  4 . ..   450000.0  2000  2023-07-01
2  103  Los Angeles  4 . ..        NaN  2500  2023-04-10
4  105  Miami  5 . ..  1200000.0  3500  2023-03-22
0  101  New York  3 . ..   750000.0  1800  2023-05-15
1  102  San Francisco  2 . ..   850000.0  1400  2023-06-01

Ordina per Camere da letto (crescente) e Prezzo (decrescente):

  PropertyID Posizione Camere da letto ...      Prezzo Metratura Data dell'annuncio
1 102 San Francisco 2...  850000.0 1400 2023-06-01
0 101 New York 3...  750000.0 1800 2023-05-15
3 104 Chicago 3...  650000,0 1700 NaN
5 106 Houston 4...  450000.0 2000 2023-07-01
2 103 Los Angeles 4...        NaN 2500 2023-04-10
4 105 Miami 5... 1200000.0 3500 2023-03-22

10. apply(): Applicare funzioni personalizzate ai dati

La funzione apply() consente di applicare funzioni personalizzate alle righe o alle colonne di un DataFrame. È un metodo potente per eseguire trasformazioni, calcoli o operazioni condizionali che vanno oltre le funzioni integrate di Pandas.

Esempio di codice:

Facciamo un esempio in cui vogliamo creare una nuova colonna per calcolare il prezzo per piede quadrato.

# Definire una funzione personalizzata per calcolare il prezzo per piede quadrato
def prezzo_per_sqft(prezzo, sqft):
  restituisce prezzo / sqft if sqft != 0 else 0

# Applicare la funzione personalizzata per creare una nuova colonna
df['PricePerSqFt'] = df.apply(lambda row: price_per_sqft(row['Price'], row['SquareFootage']), axis=1)
print(df)

Ecco l'output del codice precedente:

  PropertyID Posizione Camere da letto ...  Metratura Data dell'annuncio Prezzo per metro quadro
0 101 New York 3...          1800 2023-05-15 416.666667
1 102 San Francisco 2...          1400 2023-06-01 607.142857
2 103 Los Angeles 4... 2500 2023-04-10 NaN
3 104 Chicago 3...          1700 NaN 382.352941
4 105 Miami 5...          3500 2023-03-22 342.857143
5 106 Houston 4... 2000 2023-07-01 225.000000

Un altro esempio potrebbe essere la conversione dei nomi delle località in maiuscolo;

# Applicare una trasformazione per rendere maiuscoli tutti i nomi delle località
df['Località'] = df['Località'].apply(lambda x: x.upper())
print(df)

Ecco come si presenta:

   PropertyID Posizione Camere da letto ...      Prezzo Metratura Data dell'annuncio
0 101 NEW YORK 3...  750000.0 1800 2023-05-15
1 102 SAN FRANCISCO 2...  850000.0 1400 2023-06-01
2 103 LOS ANGELES 4...        NaN 2500 2023-04-10
3 104 CHICAGO 3...  650000,0 1700 NaN
4 105 MIAMI 5... 1200000.0 3500 2023-03-22
5 106 HOUSTON 4...  450000.0 2000 2023-07-01

Conclusione

In questa guida, abbiamo esplorato 10 funzioni Pandas essenziali per l'analisi dei dati, dal caricamento e l'ispezione dei dati con read_csv() e info() alla pulizia e alla trasformazione con metodi come isnull(), fillna(), e applicare(). Queste funzioni costituiscono la base di qualsiasi flusso di lavoro per l'analisi dei dati, consentendo di pulire, manipolare e sintetizzare i set di dati in modo efficace. La loro padronanza vi preparerà a gestire con sicurezza le sfide del mondo reale. Iniziate a esercitarvi oggi stesso e scoprite come questi strumenti possono semplificare le vostre attività di analisi!