Checklist per il profiling di un dataset
Esamini sistematicamente forma, dtypes, conteggi dei valori mancanti, valori unici e statistiche di base quando incontra un nuovo dataset.
Checklist per il profiling di un dataset è 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.
I primi cinque minuti con un dataset
Gli analisti di dati esperti seguono una checklist di profilazione sistematica ogni volta che si imbattono in un nuovo dataset. Invece di immergersi subito nell'analisi, rispondono innanzitutto a una serie di domande diagnostiche: quanto sono grandi i dati? Quali sono i tipi delle colonne? Quanti valori mancano? Sono presenti anomalie evidenti? Questo approccio strutturato evita ore di lavoro sprecato a causa di tipi di dati interpretati erroneamente o valori null nascosti che compromettono i calcoli.
import pandas as pd
# Simulate loading a new dataset
df = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv')
# Step 1: size
print('Shape:', df.shape)
print('Rows:', len(df))Passaggio 1: shape, colonne e dtypes
I primi tre controlli riguardano sempre shape (righe × colonne), nomi delle colonne (corrispondono alle aspettative?) e dtypes (le colonne numeriche sono effettivamente numeriche?). Una sorpresa frequente è che le colonne numeriche vengano caricate con dtype object perché contengono voci testuali come 'unknown' o numeri con formattazione mista e virgole. Individuare questo problema durante la profilazione evita aggregazioni che restituiscono silenziosamente risultati errati.
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
print('Shape:', df.shape)
print('\nColumns:', df.columns.tolist())
print('\nData Types:')
print(df.dtypes)Passaggio 2: verifica dei valori mancanti
Chiami df.isna().sum() per contare i valori mancanti per colonna, quindi divida per len(df) per ottenere la percentuale. Le colonne con oltre il 50% di valori mancanti sono in genere candidate alla rimozione; una percentuale di valori mancanti tra l'1% e il 20% richiede solitamente un'imputazione; lo 0% di valori mancanti necessita di un controllo di coerenza: una completezza perfetta può essere sospetta se i dati reali raramente risultano così puliti. Ordini l'output in ordine decrescente per visualizzare prima le colonne più problematiche.
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
# Missing value audit
missing = df.isna().sum()
missing_pct = (missing / len(df) * 100).round(1)
audit = pd.DataFrame({'count': missing, 'pct': missing_pct})
audit = audit[audit['count'] > 0].sort_values('pct', ascending=False)
print(audit)Passaggio 3: statistiche descrittive di base
df.describe() restituisce in un'unica chiamata il conteggio, la media, la deviazione standard, il minimo, i quartili e il massimo per ogni colonna numerica. Controlli sempre il minimo e il massimo per individuare valori impossibili (ad esempio età = -3 o età = 999), la media rispetto alla mediana per valutare l'asimmetria (una grande differenza suggerisce la presenza di outlier) e il conteggio (se è inferiore al numero totale di righe, sono presenti valori null). Aggiunga include='all' per includere anche le statistiche delle colonne di tipo object (conteggio dei valori univoci, valore più frequente e frequenza).
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
# Describe numeric columns
print('Numeric statistics:')
print(df.describe().round(2))
print('\nObject column statistics:')
print(df.describe(include='object'))Passaggio 4: conteggio dei valori univoci
Per le colonne categoriche, controlli il numero di valori univoci con df[col].nunique() ed esamini i valori più comuni con value_counts(). Presti attenzione alle colonne che sembrano categoriche ma hanno centinaia di valori univoci (potrebbero contenere testo libero o un ID) e alle colonne che dovrebbero essere booleane ma hanno tre valori (True, False e NaN). Controlli anche l'uso incoerente delle maiuscole: 'Male' e 'male' vengono trattati come categorie separate.
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
categorical = df.select_dtypes(include='object').columns
for col in categorical:
n = df[col].nunique()
top_vals = df[col].value_counts().head(3).to_dict()
print(f'{col}: {n} unique — top3: {top_vals}')Passaggio 5: righe di esempio con head e tail
df.head(10) e df.tail(10) mostrano rispettivamente le prime e le ultime righe. Esaminarle entrambe è importante perché i dataset spesso presentano righe di intestazione pulite e righe finali problematiche dovute ad artefatti dell'esportazione (ad esempio una riga riepilogativa 'Total' aggiunta a un file CSV esportato). Usi anche df.sample(10) per visualizzare una selezione casuale di righe, evitando così qualsiasi distorsione a favore dell'inizio del dataset.
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
print('First 3 rows:')
print(df.head(3))
print('\nLast 3 rows:')
print(df.tail(3))
print('\nRandom sample of 3:')
print(df.sample(3, random_state=42))Passaggio 6: verifica dei duplicati
Chiami df.duplicated().sum() per contare le righe completamente duplicate (in cui ogni colonna coincide). In un dataset che dovrebbe contenere record univoci dei clienti, anche un solo duplicato è un segnale d'allarme relativo alla qualità dei dati. Usi df[df.duplicated(keep=False)] per esaminare le righe duplicate effettive. Quando una tabella dovrebbe avere chiavi univoche (come un ID utente), controlli anche l'univocità a livello di chiave con df['id'].duplicated().sum().
import pandas as pd
import seaborn as sns
df = sns.load_dataset('titanic')
# Full-row duplicates
full_dups = df.duplicated().sum()
print(f'Fully duplicated rows: {full_dups}')
# Key-level duplicates (e.g. passenger class + name)
key_dups = df.duplicated(subset=['pclass', 'sex', 'age', 'fare']).sum()
print(f'Near-duplicate rows (pclass+sex+age+fare): {key_dups}')Passaggio 7: colonne di data e ora
Se il dataset contiene colonne con date o timestamp, controlli che Pandas le abbia caricate come datetime64 (e non come object). Le converta con pd.to_datetime(df['col']). Esamini quindi l'intervallo di date: df['date'].min() e df['date'].max(). Cerchi timestamp molto lontani nel futuro (anno 2099) o nel passato (inizio dell'epoca Unix: 1970-01-01), che indicano valori sentinella usati per rappresentare date mancanti.
import pandas as pd
# Synthetic example with a date column
df = pd.DataFrame({
'order_id': [1, 2, 3, 4],
'order_date': ['2024-01-10', '2024-02-05', '1970-01-01', '2024-12-31']
})
df['order_date'] = pd.to_datetime(df['order_date'])
print('Date range:', df['order_date'].min(), 'to', df['order_date'].max())
print('\nSuspect dates (before 2020):')
print(df[df['order_date'] < '2020-01-01'])Automatizzazione della checklist in una funzione
Racchiudere i passaggi di profilazione in una funzione riutilizzabile garantisce che gli stessi controlli vengano eseguiti in modo coerente su ogni dataset. La funzione dovrebbe stampare un report strutturato con shape, valori mancanti, dtypes, numero di duplicati e statistiche di base. Può estenderla con visualizzazioni o salvarla come report HTML. Funzioni di questo tipo sono uno strumento fondamentale nei team professionali di data science, in cui più analisti lavorano sulla stessa pipeline.
import pandas as pd
def profile(df, name='DataFrame'):
print(f'=== Profile: {name} ===')
print(f'Shape: {df.shape[0]} rows x {df.shape[1]} cols')
print(f'Duplicates: {df.duplicated().sum()}')
print(f'\nMissing values (top 5):')
missing = (df.isna().sum() / len(df) * 100).sort_values(ascending=False)
print(missing[missing > 0].head(5).round(1).to_string())
print(f'\ndtypes:')
print(df.dtypes.value_counts().to_string())
print('=' * 35)
import seaborn as sns
df = sns.load_dataset('titanic')
profile(df, 'Titanic')ydata-profiling per l'EDA automatizzata
La libreria ydata-profiling (in precedenza pandas-profiling) genera un report HTML completo da un DataFrame con una sola riga: ProfileReport(df).to_file('report.html'). Il report include istogrammi, matrici di correlazione, heatmap dei valori mancanti, rilevamento dei duplicati e grafici delle interazioni. È il modo più rapido per condividere il profilo completo di un dataset con uno stakeholder che deve comprenderne i dati senza scrivere codice.
# Install: pip install ydata-profiling
# from ydata_profiling import ProfileReport
# import pandas as pd
# import seaborn as sns
# df = sns.load_dataset('titanic')
# profile = ProfileReport(df, title='Titanic Profiling Report', explorative=True)
# profile.to_file('titanic_profile.html')
# The above generates a full HTML report automatically.
# Alternatively, use minimal mode for faster generation:
# profile = ProfileReport(df, minimal=True)
print('ydata-profiling generates HTML EDA reports automatically.')
print('Run: pip install ydata-profiling')Riepilogo della checklist di profilazione
La checklist completa per la profilazione di qualsiasi nuovo dataset comprende sette passaggi: 1) dimensioni e colonne, 2) dtypes e assegnazioni di tipo sospette, 3) conteggio e percentuale dei valori mancanti per colonna, 4) statistiche descrittive (min, max, media, mediana), 5) valori univoci e conteggi dei valori per le variabili categoriche, 6) rilevamento delle righe duplicate e 7) convalida dell'intervallo di date. Completare questa checklist prima di qualsiasi analisi previene errori silenziosi che compromettono i risultati nelle fasi successive.
Verifica rapida
Verifichi la Sua comprensione della checklist per la profilazione dei dataset presentata in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato: la checklist di profilazione in 7 passaggi (dimensioni, dtypes, valori mancanti, statistiche, conteggi dei valori univoci, duplicati, date), come racchiudere i controlli in una funzione di profilazione riutilizzabile e come usare ydata-profiling per generare report HTML automatici. Ora passeremo all'analisi univariata, ovvero allo studio indipendente di ogni colonna per individuare outlier, asimmetria e distribuzioni insolite.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Checklist per il profiling di un dataset» è gratuita?
Sì — il testo completo di «Checklist per il profiling di un dataset» è 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 «Checklist per il profiling di un dataset»?
Esamini sistematicamente forma, dtypes, conteggi dei valori mancanti, valori unici e statistiche di base quando incontra un nuovo dataset. 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 «Checklist per il profiling di un dataset»?
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
- Checklist per il profiling di un dataset
- Analisi univariata
- Analisi bivariata e della correlazione
- Riassumere i risultati in un report