PricingLoginStart free
Pandas & NumPy Academy · Lezione

Pandas o SQL: scegliere lo strumento giusto

Confronti groupby/merge in Pandas con GROUP BY/JOIN in SQL e decida quale livello debba gestire ciascuna trasformazione.

Lezione 4 di 413 passaggi

Pandas o SQL: scegliere lo strumento giusto è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Due strumenti, punti di forza complementari

Sia Pandas sia SQL sono strumenti per la manipolazione dei dati e vengono entrambi utilizzati dagli analisti di dati professionisti. L'idea fondamentale è che siano complementari, non concorrenti: SQL eccelle nelle operazioni dichiarative basate su insiemi su tabelle di grandi dimensioni memorizzate in database relazionali, mentre Pandas eccelle nelle trasformazioni imperative, riga per riga e algoritmiche complesse sui dati già caricati in memoria. Le pipeline migliori utilizzano ciascuno strumento per ciò che sa fare meglio.

Punti di forza di SQL: cosa fa meglio SQL

SQL è generalmente superiore quando: i dati sono numerosi (da gigabyte a terabyte) e devono essere filtrati prima del caricamento; le join coinvolgono più tabelle di grandi dimensioni e gli indici del database offrono miglioramenti di velocità di un ordine di grandezza; le aggregazioni sono semplici (SUM, COUNT, GROUP BY); i set di risultati sono piccoli rispetto all'input; oppure sono necessarie letture e scritture concorrenti (il database gestisce transazioni e blocchi). La sintassi dichiarativa di SQL consente inoltre agli ottimizzatori delle query di scegliere automaticamente il miglior piano fisico.

-- SQL excels at:
-- 1. Filtering billions of rows using an index
SELECT * FROM orders WHERE customer_id = 12345;

-- 2. Joining large tables efficiently
SELECT o.order_id, c.name, SUM(o.amount)
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY o.order_id, c.name;

-- 3. Window functions on ordered data
SELECT order_id, amount,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date)
FROM orders;

Punti di forza di Pandas: cosa fa meglio Pandas

Pandas è generalmente superiore quando: serve una logica Python personalizzata che SQL non è in grado di esprimere (pre-elaborazione per il machine learning, analisi personalizzata delle stringhe, algoritmi complessi); le catene di trasformazione dei dati sono composte da numerosi passaggi; serve una visualizzazione subito dopo l'analisi; i dati sono già in memoria e ulteriori round trip verso SQL aggiungerebbero latenza; oppure si sta eseguendo un'analisi esplorativa che richiede iterazioni interattive. Pandas gestisce anche operazioni non tabellari, come il calcolo matriciale e lo smoothing delle serie temporali.

import pandas as pd

# Pandas excels at:
# 1. Custom Python logic that SQL cannot express
df['clean_name'] = df['name'].str.strip().str.title().str.replace(r'[^a-zA-Z ]', '', regex=True)

# 2. Vectorised string parsing
df[['first', 'last']] = df['full_name'].str.split(' ', n=1, expand=True)

# 3. Rolling statistics and time series
df['7day_avg'] = df['daily_sales'].rolling(7).mean()

# 4. Direct visualisation
# df.groupby('category')['sales'].sum().plot(kind='bar')

Associare le operazioni SQL a Pandas

La maggior parte delle operazioni SQL ha un equivalente diretto in Pandas. Conoscere entrambe le sintassi la rende più versatile e aiuta a passare da uno strumento all'altro. WHERE diventa l'indicizzazione booleana o .query(); GROUP BY + SUM diventa .groupby().sum(); JOIN diventa pd.merge(); ORDER BY diventa .sort_values(); e DISTINCT diventa .drop_duplicates(). Il significato semantico è identico: cambia solo la sintassi.

import pandas as pd

df = pd.DataFrame({'region': ['N','S','N','E'], 'amount': [100,200,150,300]})

# SQL: SELECT region, SUM(amount) FROM df WHERE amount>100 GROUP BY region ORDER BY region
# Pandas:
result = (
    df[df['amount'] > 100]
    .groupby('region')['amount']
    .sum()
    .reset_index()
    .sort_values('region')
)
print(result)

Quando la dimensione dei dati determina la scelta

Un criterio decisionale pratico basato sulla dimensione dei dati: meno di 100 MB — utilizzi esclusivamente Pandas, poiché il sovraccarico di SQL non vale la pena; da 100 MB a 10 GB — filtri e aggreghi in SQL, quindi carichi un DataFrame riepilogativo in Pandas; da 10 GB a 1 TB — utilizzi SQL o Dask per l'elaborazione e Pandas solo per il riepilogo finale; oltre 1 TB — utilizzi SQL distribuito (BigQuery, Spark SQL, Redshift). Non cerchi mai di caricare una tabella da 100 GB in Pandas su un laptop con 16 GB di RAM: il sistema si bloccherebbe o utilizzerebbe intensivamente il disco.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///large.db')

# Right approach: SQL handles the heavy lifting
summary_df = pd.read_sql_query(
    '''
    SELECT region, product_category,
           SUM(revenue) AS total_revenue,
           COUNT(DISTINCT customer_id) AS unique_customers
    FROM orders
    WHERE order_date >= '2024-01-01'
    GROUP BY region, product_category
    ''',
    con=engine
)
# summary_df is small — now do Pandas things on it
print(summary_df.sort_values('total_revenue', ascending=False))

Funzioni finestra SQL e rolling di Pandas

Le window functions di SQL (OVER (PARTITION BY ... ORDER BY ...)) sono potenti, ma presentano alcune limitazioni: calcolano bene classifiche cumulative, valori precedenti/successivi e semplici aggregazioni mobili, mentre statistiche mobili complesse (ad esempio, la correlazione di Pearson mobile) non sono esprimibili in SQL. I metodi rolling() ed expanding() di Pandas coprono una gamma molto più ampia di calcoli su finestre, incluse funzioni personalizzate tramite .apply(). Per le window functions standard su grandi quantità di dati, preferisca SQL; per la logica su finestre complessa, preferisca Pandas.

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=30),
    'sales': [100 + i*10 + (i%7)*20 for i in range(30)]
})

# Pandas rolling — easy with arbitrary window functions
df['7d_mean'] = df['sales'].rolling(7).mean()
df['7d_std']  = df['sales'].rolling(7).std()
df['7d_corr'] = df['sales'].rolling(7).corr(df['sales'].shift(1))
print(df.tail())

Join complessi: la flessibilità di Pandas

I join SQL si basano sull'uguaglianza delle chiavi, con alcune eccezioni. Pandas, tramite pd.merge_asof(), supporta join approssimati basati sul tempo (che associano la chiave più vicina invece di richiedere un'uguaglianza esatta), una funzionalità preziosa per allineare serie temporali, ad esempio unendo i prezzi azionari agli eventi di trading in corrispondenza del prezzo precedente più vicino. Pandas supporta inoltre i join condizionali usando merge seguito da un filtro; in SQL è necessario esprimerli tramite una subquery o un join LATERAL. Questi pattern di join avanzati sono un ambito in cui Pandas offre chiaramente maggiori vantaggi.

import pandas as pd

trades = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:05', '2024-01-01 10:12']),
    'symbol': ['AAPL', 'AAPL', 'AAPL'],
    'shares': [100, 200, 50]
})
prices = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:10']),
    'price': [185.0, 186.5]
})

# Fuzzy join: match each trade to the nearest preceding price
result = pd.merge_asof(trades.sort_values('time'),
                       prices.sort_values('time'),
                       on='time', direction='backward')
print(result)

Pandas per la profilazione dei dati, SQL per la produzione

Un flusso di lavoro comune consiste nell'usare Pandas per l'EDA e la profilazione dei dati su un campione rappresentativo, ad esempio le prime milioni di righe, sviluppare iterativamente la logica di trasformazione e poi tradurre i passaggi principali in SQL per la scala di produzione. Pandas consente iterazioni rapide con un riscontro visivo immediato; SQL viene eseguito in modo affidabile su larga scala con un'infrastruttura minima. Mantenga sincronizzati i due ambienti: quando aggiunge una nuova feature in Pandas, scriva la stored procedure o la view SQL equivalente per la produzione.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///data.db')

# Development: sample in Pandas for fast iteration
df_sample = pd.read_sql_query(
    'SELECT * FROM orders ORDER BY RANDOM() LIMIT 10000',
    con=engine
)
# Explore and prototype:
df_sample['revenue_tier'] = pd.cut(
    df_sample['amount'],
    bins=[0, 100, 500, float('inf')],
    labels=['low', 'mid', 'high']
)
print(df_sample['revenue_tier'].value_counts())
# Production: translate cut logic to SQL CASE WHEN

pandasql: scrivere query SQL sui DataFrame

La libreria pandasql consente di scrivere query SQL direttamente sui DataFrame di Pandas, usando SQLite internamente. sqldf('SELECT * FROM df WHERE amount > 100', locals()) esegue la query sul DataFrame df. È utile se ragiona in termini di SQL ma i dati sono già in Pandas, oppure per insegnare i concetti di SQL con dati in memoria. Tuttavia, per la maggior parte delle operazioni è più lenta di Pandas nativo: la usi per familiarità, non per le prestazioni.

# pip install pandasql
import pandas as pd
# from pandasql import sqldf

df = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B'],
    'sales': [100, 200, 150, 80, 220]
})

# With pandasql (commented out as it requires install):
# result = sqldf('SELECT product, SUM(sales) AS total FROM df GROUP BY product', locals())

# Equivalent native Pandas:
result = df.groupby('product')['sales'].sum().reset_index()
print(result)

Schema decisionale: un riferimento rapido

Usi questa guida decisionale per scegliere tra SQL e Pandas:

  • I dati sono in un database E sono numerosi? Filtri e aggreghi prima in SQL.
  • Ha bisogno di una logica Python personalizzata? Usi Pandas dopo un pre-filtro SQL.
  • Sta eseguendo un'analisi esplorativa su un campione? Pandas consente iterazioni più rapide.
  • Sta lavorando con serie temporali e statistiche mobili complesse? Usi rolling/ewm di Pandas.
  • Deve eseguire un semplice GROUP BY su milioni di righe? Usi SQL con gli indici.
  • Ha già in memoria più DataFrame di piccole dimensioni? pd.merge() è adatto.
  • Ha bisogno di transazioni ACID? Usi un database SQL, non Pandas.

Combinare entrambi: la pipeline ibrida

L'approccio più pratico è una pipeline ibrida che sfrutta i punti di forza di ciascuno strumento. SQL gestisce l'acquisizione, il filtraggio preliminare e le aggregazioni standard su grandi tabelle grezze. L'output, ovvero un DataFrame di dimensioni gestibili, viene passato a Pandas per la progettazione delle feature, le metriche personalizzate, le statistiche mobili e la visualizzazione. I risultati possono poi essere riscritti facoltativamente nel database per la distribuzione. Questa pipeline è leggibile, scalabile e manutenibile da qualsiasi analista che conosca SQL e Python.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///pipeline.db')

# Step 1: SQL coarse aggregation
df = pd.read_sql_query('''
    SELECT DATE(order_date) AS date, region, SUM(amount) AS daily_revenue
    FROM orders WHERE status = 'completed'
    GROUP BY DATE(order_date), region
    ORDER BY date
''', con=engine, parse_dates=['date'])

# Step 2: Pandas rolling and pivoting (hard in SQL)
df['7d_avg'] = df.groupby('region')['daily_revenue'].transform(
    lambda x: x.rolling(7, min_periods=1).mean()
)
pivot = df.pivot(index='date', columns='region', values='7d_avg')
print(pivot.tail())

Verifica rapida

Verifichi la Sua comprensione dei concetti di analisi dei dati trattati in questa lezione.

Rispondi nella lezione interattiva

Riepilogo della lezione

In questa lezione ha imparato che SQL eccelle nel filtraggio e nei join su larga scala e nelle aggregazioni semplici su dati indicizzati, che Pandas eccelle nella logica Python personalizzata, nelle statistiche mobili complesse e nell'analisi esplorativa e che la strategia migliore è una pipeline ibrida che usa SQL per la riduzione preliminare e Pandas per le trasformazioni complesse sul risultato di dimensioni gestibili. Ora inizieremo la statistica inferenziale con SciPy: test di normalità e statistiche descrittive.

Gratis per iniziare

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
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Pandas o SQL: scegliere lo strumento giusto» è gratuita?

Sì — il testo completo di «Pandas o SQL: scegliere lo strumento giusto» è 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 «Pandas o SQL: scegliere lo strumento giusto»?

Confronti groupby/merge in Pandas con GROUP BY/JOIN in SQL e decida quale livello debba gestire ciascuna trasformazione. 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 4 di 4.

Quanto tempo richiede la lezione «Pandas o SQL: scegliere lo strumento giusto»?

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. Connettersi a un database con SQLAlchemy
  2. Eseguire query SQL da Pandas
  3. Scrivere DataFrame nelle tabelle del database
  4. Pandas o SQL: scegliere lo strumento giusto
← Torna a Pandas & NumPy Academy