Configurazione del progetto e acquisizione dei dati
Definisca gli obiettivi del progetto, carichi i dati da un CSV e da un database SQLite, unisca le origini ed esegua un audit completo del dataset combinato.
Configurazione del progetto e acquisizione dei dati è 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.
Obiettivo del progetto conclusivo
In questo progetto conclusivo riunirà tutte le competenze del corso — NumPy, Pandas, visualizzazione, test statistici, connessione ai database e progettazione di pipeline — in un unico flusso di lavoro completo. Il progetto simula un'attività reale di analisi: acquisire dati grezzi da due fonti (un file CSV e una tabella di database), unirli, verificare la qualità dei dati, calcolare KPI avanzati, visualizzare le tendenze ed esportare un report accurato. È un'attività analoga a ciò che gli analisti dei dati professionisti svolgono ogni giorno nel settore.
Definizione degli obiettivi del progetto e dei KPI
Prima di scrivere una sola riga di codice, definisca gli obiettivi del progetto e gli indicatori chiave di prestazione (KPI) che calcolerà. Documenti: a quale domanda aziendale sta rispondendo? Quali fonti di dati ha a disposizione? Quali formati di output sono necessari? Per questo progetto conclusivo: analizzare le tendenze mensili dei ricavi per categoria di prodotto, calcolare la fidelizzazione per coorte, identificare le aree geografiche principali in base al margine di profitto ed esportare un report con visualizzazioni. Un obiettivo chiaro evita l'ampliamento incontrollato dell'ambito e mantiene la pipeline focalizzata.
# Project configuration — define goals upfront
CONFIG = {
'csv_path': 'data/orders_2024.csv',
'db_url': 'sqlite:///customer_db.sqlite',
'db_table': 'customers',
'output_dir': 'output/',
'report_path': 'output/report.md',
'analysis_year': 2024,
'top_n_regions': 5,
'rolling_window_days': 30
}
print('Project config loaded.')
print('Target KPIs: monthly revenue, cohort retention, top regions by margin')Caricamento dei dati da CSV
Carichi il CSV specificando esplicitamente gli argomenti dtype e parse_dates per evitare errori di inferenza. In un progetto reale, il CSV potrebbe essere stato esportato da un sistema diverso, con convenzioni differenti: imposti encoding, sep e thousands se necessario. Controlli subito shape, dtypes e head() per verificare che il caricamento sia avvenuto correttamente prima di qualsiasi trasformazione. Questa prima ispezione rivela spesso problemi di codifica, righe di intestazione aggiuntive o nomi di colonne imprevisti.
import pandas as pd
df_orders = pd.read_csv(
'data/orders_2024.csv',
dtype={
'order_id': 'int32',
'customer_id': 'int32',
'product_id': 'int32',
'quantity': 'int16',
'unit_price': 'float32',
'region': 'category',
'category': 'category'
},
parse_dates=['order_date'],
encoding='utf-8'
)
print(f'Orders loaded: {df_orders.shape}')
print(df_orders.dtypes)
print(df_orders.head(3))Caricamento dei dati dal database
La seconda fonte di dati è la tabella dei clienti in un database SQLite. Carichi solo le colonne necessarie all'analisi tramite un'istruzione SQL SELECT, invece di caricare l'intera tabella. Unisca le due fonti usando customer_id per arricchire ogni ordine con i dati demografici del cliente. Prima dell'unione, verifichi che le chiavi customer_id abbiano lo stesso tipo in entrambe le fonti: una causa comune di errori silenziosi nell'unione è confrontare una chiave int32 con una chiave stringa.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///customer_db.sqlite')
df_customers = pd.read_sql_query(
'''
SELECT customer_id, customer_name, country,
acquisition_channel, signup_date
FROM customers
''',
con=engine,
dtype={'customer_id': 'int32'},
parse_dates=['signup_date']
)
print(f'Customers loaded: {df_customers.shape}')
print(df_customers.dtypes)
print(df_customers.head(3))Unione delle due fonti
Unisca gli ordini ai clienti usando customer_id con un'operazione di left join, così da mantenere tutti gli ordini anche se manca il record di un cliente. Dopo l'unione, controlli quanti ordini non hanno un cliente corrispondente (customer_name.isna().sum()): è un indicatore della qualità dei dati che vale la pena analizzare. Verifichi la forma del DataFrame risultante per assicurarsi che l'unione non abbia duplicato né eliminato righe inaspettate. Documenti la logica dell'unione in un commento per i futuri responsabili della manutenzione.
import pandas as pd
# Left join: keep all orders, enrich with customer data where available
df = pd.merge(
df_orders,
df_customers,
on='customer_id',
how='left'
)
print(f'Orders: {len(df_orders)}, Customers: {len(df_customers)}')
print(f'Merged: {df.shape}')
unmatched = df['customer_name'].isna().sum()
print(f'Orders with no matching customer: {unmatched} ({unmatched/len(df):.1%})')Checklist completa per l'audit dei dati
Dopo il caricamento e l'unione, esegua un audit sistematico dei dati prima di qualsiasi analisi. Controlli: numero totale di righe e colonne, valori mancanti per colonna (in percentuale), tipi di dati di tutte le colonne, ID ordine duplicati, intervallo di date coperto, valori negativi nelle colonne numeriche e cardinalità delle colonne categoriche. Documenti i risultati in un riepilogo testuale. Individuare qui i problemi di qualità dei dati previene errori silenziosi nei calcoli successivi dei KPI.
import pandas as pd
def audit_dataframe(df, name='DataFrame'):
print(f'=== Audit: {name} ===')
print(f'Shape: {df.shape}')
print(f'Date range: {df["order_date"].min()} to {df["order_date"].max()}')
print(f'Duplicate order_ids: {df["order_id"].duplicated().sum()}')
print('Missing values:')
missing = df.isnull().sum()
print(missing[missing > 0].to_string())
print('Negative quantities:', (df['quantity'] < 0).sum())
print('Negative prices:', (df['unit_price'] < 0).sum())
print()
audit_dataframe(df, 'Merged Orders + Customers')Correzione delle anomalie nell'analisi delle date
Le colonne di date provenienti da esportazioni CSV presentano spesso casi particolari: date future che non dovrebbero esistere, date di un anno errato (un comune errore di inserimento) oppure date mancanti per gli ordini annullati. Dopo aver analizzato le date, convalidi l'intervallo previsto e sostituisca i valori fuori intervallo con NaT. Controlli inoltre gli ordini per cui order_date < customer signup_date: si tratta di eventi impossibili che indicano problemi di qualità dei dati da segnalare nel report di audit.
import pandas as pd
from datetime import datetime
# Flag impossible dates
df['date_valid'] = (
(df['order_date'] >= '2024-01-01') &
(df['order_date'] <= datetime.now())
)
print('Invalid order dates:', (~df['date_valid']).sum())
# Flag orders before customer signup
df['signup_date'] = pd.to_datetime(df['signup_date'])
df['date_before_signup'] = df['order_date'] < df['signup_date']
print('Orders before customer signup:', df['date_before_signup'].sum())
# Set invalid dates to NaT
df.loc[~df['date_valid'], 'order_date'] = pd.NaTGestione delle quantità negative e dei resi
Le quantità negative in una tabella degli ordini rappresentano in genere resi o rimborsi. Invece di eliminarle semplicemente, le separi in due DataFrame: ordini positivi e resi. In questo modo può calcolare separatamente i ricavi lordi (solo ordini positivi) e i ricavi netti (positivi + negativi), ottenendo un quadro più accurato dell'attività. Aggiunga a ogni riga una colonna booleana is_return e mantenga entrambi i tipi nel DataFrame unito per finalità di audit.
import pandas as pd
# Tag returns
df['is_return'] = df['quantity'] < 0
returns = df[df['is_return']]
orders = df[~df['is_return']]
print(f'Normal orders: {len(orders)}')
print(f'Returns/refunds: {len(returns)} ({len(returns)/len(df):.1%})')
print(f'Return rate by category:')
print(
df.groupby('category')['is_return']
.mean()
.sort_values(ascending=False)
.round(3)
)Verifica della completezza dell'unione
Dopo un left join, verifichi che l'unione sia completa come previsto. Conti quanti valori univoci di customer_id compaiono negli ordini ma non nella tabella dei clienti. Si tratta di record orfani: clienti che hanno effettuato ordini ma non dispongono di un record cliente. Potrebbero rappresentare account eliminati, acquisti come ospiti o una lacuna nella pipeline dei dati. Documenti il numero e decida se escluderli dall'analisi della fidelizzazione, includendoli però nei totali dei ricavi.
import pandas as pd
order_customers = set(df_orders['customer_id'].unique())
customer_ids = set(df_customers['customer_id'].unique())
orphans = order_customers - customer_ids
print(f'Customer IDs in orders not in customer table: {len(orphans)}')
print(f'Coverage: {len(order_customers & customer_ids) / len(order_customers):.1%} of order customers have records')
# Revenue from unmatched customers
orphan_revenue = df[df['customer_id'].isin(orphans)]['unit_price'].sum()
print(f'Revenue from orphan customers: ${orphan_revenue:,.0f}')Salvataggio del dataset sottoposto ad audit
Dopo l'audit, salvi il dataset pulito e unito in formato Parquet, così che i passaggi successivi della pipeline (ingegneria delle caratteristiche, calcolo dei KPI e visualizzazione) possano ricaricarlo immediatamente senza ripetere le operazioni di unione e analisi. Scriva file separati per gli ordini puliti e per il DataFrame dei resi. Questo schema basato su checkpoint rende la pipeline ripristinabile e consente di eseguire il debug delle fasi successive senza ripetere l'acquisizione dei dati.
import os
import pandas as pd
OS_DIR = 'output/'
os.makedirs(OS_DIR, exist_ok=True)
# Save clean orders (excluding returns and invalid dates)
clean_orders = df[
(~df['is_return']) &
df['order_date'].notna()
].copy()
clean_orders.to_parquet(OS_DIR + 'clean_orders.parquet', index=False)
df[df['is_return']].to_parquet(OS_DIR + 'returns.parquet', index=False)
print(f'Clean orders saved: {len(clean_orders):,} rows')
print(f'Returns saved: {len(df[df["is_return"]]):,} rows')
print(f'Files in {OS_DIR}: {os.listdir(OS_DIR)}')Report riepilogativo dell'audit
L’ultimo passaggio dell’acquisizione dei dati consiste nella scrittura di un breve riepilogo di audit che registri ciò che è stato rilevato. Può trattarsi di un log stampato o di un file Markdown. Includa: il numero di righe caricate da ciascuna origine, il tasso di corrispondenza dell’unione, l’intervallo di date, la percentuale di valori mancanti, il numero di resi individuati e qualsiasi anomalia. Il riepilogo di audit diventa parte del deliverable finale e aiuta gli stakeholder ad avere fiducia nel fatto che i dati siano stati puliti correttamente prima dell’analisi.
import pandas as pd
from datetime import datetime
def write_audit_summary(df, path):
lines = [
'# Data Ingestion Audit',
f'Generated: {datetime.now().strftime("%Y-%m-%d %H:%M")}',
'',
f'- Total records after merge: {len(df):,}',
f'- Clean orders: {(~df["is_return"]).sum():,}',
f'- Returns: {df["is_return"].sum():,}',
f'- Date range: {df["order_date"].min().date()} to {df["order_date"].max().date()}',
f'- Unique customers: {df["customer_id"].nunique():,}',
f'- Unique categories: {df["category"].nunique()}',
f'- Missing unit_price: {df["unit_price"].isna().sum()}'
]
with open(path, 'w') as f:
f.write('\n'.join(lines))
write_audit_summary(df, 'output/audit.md')
print('Audit summary written.')Verifica rapida
Verifichi la Sua comprensione dei concetti di analisi dei dati trattati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: la definizione anticipata di obiettivi e configurazione mantiene la pipeline focalizzata e manutenibile, gli argomenti dtype e parse_dates espliciti in read_csv prevengono gli errori di tipo silenziosi e una checklist sistematica per l’audit dei dati (duplicati, valori mancanti, date impossibili, quantità negative) rileva i problemi di qualità prima che compromettano il calcolo dei KPI. Ora passeremo alla pulizia dei dati e alla creazione di feature per l’analisi.
Domande Frequenti
La lezione «Configurazione del progetto e acquisizione dei dati» è gratuita?
Sì — il testo completo di «Configurazione del progetto e acquisizione dei dati» è 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 «Configurazione del progetto e acquisizione dei dati»?
Definisca gli obiettivi del progetto, carichi i dati da un CSV e da un database SQLite, unisca le origini ed esegua un audit completo del dataset combinato. 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 «Configurazione del progetto e acquisizione dei dati»?
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
- Configurazione del progetto e acquisizione dei dati
- Pulizia dei dati e feature engineering
- Analisi e calcolo dei KPI
- Visualizzazione finale ed esportazione del report