0Pricing
Pandas & NumPy Academy · Lezione

Rilevare i valori mancanti

Usi isna(), notna() e isnull() per trovare le posizioni di NaN in una Series o DataFrame e contare i valori mancanti per colonna.

Rilevare i valori mancanti è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Che cosa sono i valori mancanti in Pandas?

In Pandas, un valore mancante è rappresentato come NaN (Not a Number) nelle colonne numeriche e come None o pd.NaT nelle colonne datetime. I dati mancanti sono comuni nei dataset del mondo reale perché i record possono essere incompleti, i sensori possono guastarsi oppure le join possono generare righe senza corrispondenza. Rilevare i valori mancanti è sempre il primo passaggio in qualsiasi flusso di lavoro di pulizia dei dati.

Pandas normalizza None, float('nan') e numpy.nan nella stessa rappresentazione interna NaN per le colonne numeriche.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'name': ['Alice', None, 'Carol'],
    'age': [25, np.nan, 30],
    'salary': [50000.0, 60000.0, np.nan]
})
print(df)
#     name   age   salary
# 0  Alice  25.0  50000.0
# 1   None   NaN  60000.0
# 2  Carol  30.0      NaN

isna() e isnull()

isna() e isnull() sono completamente identici: entrambi restituiscono un DataFrame o una Series della stessa forma, contenente True dove il valore è mancante e False altrove. Pandas fornisce entrambi i nomi esclusivamente per lasciare la scelta all'utente. Il risultato può essere usato direttamente come maschera booleana per il filtraggio o per ulteriori calcoli.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, np.nan, 3],
    'B': [np.nan, 2, np.nan]
})

print(df.isna())
#        A      B
# 0  False   True
# 1   True  False
# 2  False   True

# Both are identical
print((df.isna() == df.isnull()).all().all())  # True

notna() per trovare i valori non mancanti

notna() (disponibile anche come alias notnull()) è l'inverso di isna(): restituisce True dove i valori sono presenti e False dove sono mancanti. È utile quando desiderate filtrare le righe che contengono un valore in una colonna importante, ad esempio imponendo che una chiave primaria o una variabile target non sia NaN.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'id': [1, 2, 3],
    'email': ['a@x.com', None, 'c@x.com']
})

# Keep only rows where email is present
with_email = df[df['email'].notna()]
print(with_email)
#    id    email
# 0   1  a@x.com
# 2   3  c@x.com

Contare i valori mancanti per colonna

Chiamando .isna().sum() su un DataFrame si sommano i valori True (che equivalgono a 1) colonna per colonna, ottenendo il conteggio dei valori mancanti per colonna. È il primo passaggio più utile per comprendere la qualità di un nuovo dataset: indica quali colonne richiedono attenzione.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'name': ['Alice', None, 'Carol', None],
    'age': [25, np.nan, 30, 22],
    'salary': [50000, 60000, np.nan, np.nan]
})

missing_counts = df.isna().sum()
print(missing_counts)
# name      2
# age       1
# salary    2
# dtype: int64

Percentuale di valori mancanti per colonna

Un conteggio assoluto dei valori NaN è meno utile della percentuale di valori mancanti, perché il conteggio varia in base alle dimensioni del dataset. Dividendo isna().sum() per il numero totale di righe (oppure chiamando isna().mean()) ottenete la frazione di valori mancanti, che potete moltiplicare per 100 per ottenere una percentuale. Le colonne con oltre il 30-50% di valori mancanti richiedono spesso una decisione sull'opportunità di conservarle.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, np.nan, 3, np.nan, 5],
    'B': [np.nan, 2, np.nan, 4, 5],
    'C': [1, 2, 3, 4, 5]
})

missing_pct = (df.isna().mean() * 100).round(1)
print(missing_pct)
# A    40.0
# B    40.0
# C     0.0
# dtype: float64

Tabella riepilogativa dei valori mancanti

Un pattern comune nell'EDA consiste nel creare una tabella riepilogativa dei valori mancanti che mostri conteggio, percentuale e dtype di ogni colonna in un'unica vista. Offre un quadro completo della qualità dei dati prima di prendere decisioni sulla pulizia. Potete ordinarla per portare in cima le colonne più problematiche.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'col_a': [1, np.nan, 3],
    'col_b': [np.nan, np.nan, 3],
    'col_c': [1, 2, 3]
})

summary = pd.DataFrame({
    'missing_count': df.isna().sum(),
    'missing_pct': (df.isna().mean() * 100).round(1),
    'dtype': df.dtypes
}).sort_values('missing_pct', ascending=False)
print(summary)
#         missing_count  missing_pct   dtype
# col_b               2         66.7  float64
# col_a               1         33.3  float64
# col_c               0          0.0  float64

Conteggio dei valori mancanti a livello di riga

Potete anche contare i valori mancanti per riga chiamando isna().sum(axis=1). Questo aiuta a identificare i record quasi vuoti (ad esempio risposte incomplete a un sondaggio), che potreste voler segnalare o rimuovere nel loro insieme. Una riga con molti valori mancanti è fondamentalmente diversa da valori mancanti sparsi a livello di colonna.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'a': [1, np.nan, np.nan],
    'b': [np.nan, 2, np.nan],
    'c': [3, 4, np.nan]
})

# Count NaN per row
df['missing_count'] = df.isna().sum(axis=1)
print(df)
#      a    b    c  missing_count
# 0  1.0  NaN  3.0              1
# 1  NaN  2.0  4.0              1
# 2  NaN  NaN  NaN              3

Filtrare le righe con valori mancanti in parte o del tutto

Usate df[df.isna().any(axis=1)] per trovare le righe che contengono almeno un valore NaN, oppure df[df.isna().all(axis=1)] per trovare le righe in cui ogni valore è NaN. Questi filtri aiutano a isolare i record problematici per esaminarli prima di decidere come gestirli.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'x': [1, np.nan, np.nan],
    'y': [2, 3, np.nan],
    'z': [4, 5, np.nan]
})

# Rows with at least one NaN
has_any_nan = df[df.isna().any(axis=1)]
print('Any NaN:\n', has_any_nan)

# Rows where all values are NaN
all_nan = df[df.isna().all(axis=1)]
print('All NaN:\n', all_nan)
#      x    y    z
# 2  NaN  NaN  NaN

Controllare la presenza di NaN in una colonna specifica

Per un rapido controllo di coerenza su una singola colonna, chiamate df['col'].isna().sum() oppure usate df['col'].isna().any() per ottenere un singolo valore booleano (True se esiste almeno un NaN). Queste istruzioni su una sola riga sono utili nei controlli di validazione dei dati o nelle istruzioni di logging di una pipeline.

import pandas as pd
import numpy as np

df = pd.DataFrame({'price': [10.0, np.nan, 30.0, np.nan, 50.0]})

print('NaN count in price:', df['price'].isna().sum())  # 2
print('Any NaN in price?', df['price'].isna().any())    # True
print('All present?', df['price'].notna().all())         # False

Visualizzare i valori mancanti con una heatmap

Per i dataset con molte colonne, una heatmap dei valori mancanti è più informativa di una tabella di numeri. Potete crearne facilmente una con Seaborn: più scura è una cella, maggiore è la quantità di dati mancanti nella combinazione colonna-riga corrispondente. Una popolare libreria di terze parti chiamata missingno offre visualizzazioni dedicate ai valori mancanti.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

np.random.seed(0)
df = pd.DataFrame(
    np.where(np.random.rand(20, 5) > 0.7, np.nan, np.random.randn(20, 5)),
    columns=['A', 'B', 'C', 'D', 'E']
)

# Heatmap of missing values
sns.heatmap(df.isna(), cbar=False, yticklabels=False)
plt.title('Missing Value Pattern')
plt.tight_layout()
plt.savefig('missing_heatmap.png')
print('Saved missing_heatmap.png')

info() per un controllo rapido dei valori mancanti

df.info() stampa un riepilogo conciso che include il conteggio dei valori non nulli per ogni colonna. È il modo più rapido per individuare le colonne con valori mancanti in un nuovo dataset: qualsiasi colonna il cui conteggio dei valori non nulli sia inferiore al numero totale di righe contiene valori NaN. Mostra anche dtype e utilizzo della memoria.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'id': [1, 2, 3, 4, 5],
    'age': [25, np.nan, 30, np.nan, 22],
    'salary': [50000, 60000, np.nan, 70000, 80000]
})

df.info()
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 5 entries, 0 to 4
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   id      5 non-null      int64
#  1   age     3 non-null      float64
#  2   salary  4 non-null      float64

Verifica rapida

Verificate la vostra comprensione del rilevamento dei valori mancanti in Pandas.

Riepilogo della lezione

In questa lezione avete imparato che: isna() e isnull() sono identici e restituiscono maschere booleane delle posizioni mancanti, isna().sum() conta i NaN per colonna e isna().mean()*100 restituisce la percentuale di valori mancanti. Usate df.info() per una panoramica rapida e isna().any(axis=1) per trovare le righe con almeno un NaN. Nella prossima lezione vedremo come eliminare i valori mancanti con dropna().

Domande Frequenti

La lezione «Rilevare i valori mancanti» è gratuita?

Sì — il testo completo di «Rilevare i valori mancanti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Rilevare i valori mancanti»?

Usi isna(), notna() e isnull() per trovare le posizioni di NaN in una Series o DataFrame e contare i valori mancanti per colonna. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Rilevare i valori mancanti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Rilevare i valori mancanti
  2. Eliminare i valori mancanti
  3. Riempire i valori mancanti
  4. Interpolazione e imputazione avanzata
← Torna a Pandas & NumPy Academy