Connettersi a un database con SQLAlchemy
Crei un engine SQLAlchemy per SQLite e PostgreSQL e lo passi a pd.read_sql per caricare una tabella in un DataFrame.
Connettersi a un database con SQLAlchemy è 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.
Perché collegare Pandas ai database?
La maggior parte dei dati di produzione risiede in database relazionali — PostgreSQL, MySQL, SQLite o SQL Server — e non in file CSV. Collegare direttamente Pandas a un database consente di caricare i dati in un DataFrame tramite una query senza doverli prima esportare in CSV, reinserire i DataFrame puliti nelle tabelle e combinare la potenza analitica di Python con le funzionalità di indicizzazione e join del database. Il ponte tra Pandas e i database è SQLAlchemy, la libreria standard di astrazione dei database per Python.
Installare SQLAlchemy
SQLAlchemy è un toolkit SQL e ORM per Python. Per l'integrazione con Pandas è sufficiente il livello Core, non l'ORM. Lo installi con pip install sqlalchemy. Le serve anche il driver specifico del database: psycopg2 per PostgreSQL, pymysql per MySQL oppure sqlite3 (integrato in Python) per SQLite. SQLAlchemy funge da livello di astrazione: lo stesso codice Pandas funziona con qualsiasi database supportato, modificando soltanto la stringa di connessione.
# Install dependencies
# pip install sqlalchemy psycopg2-binary # for PostgreSQL
# pip install sqlalchemy pymysql # for MySQL
# sqlite3 is built into Python
import sqlalchemy as sa
import pandas as pd
print('SQLAlchemy version:', sa.__version__)Creare un motore di connessione
Il primo passaggio consiste nel creare un motore SQLAlchemy usando un URL di connessione che codifica il tipo di database, le credenziali, l'host, la porta e il nome del database. Il motore è una factory per le connessioni al database: non apre una connessione finché non ne ha effettivamente bisogno. Passi il motore alle funzioni Pandas pd.read_sql() e df.to_sql(). Non inserisca mai le credenziali direttamente nel codice; le legga dalle variabili d'ambiente o da un gestore dei segreti.
import sqlalchemy as sa
import os
# SQLite (file-based, no server needed)
sqlite_engine = sa.create_engine('sqlite:///mydata.db')
# PostgreSQL
# pg_url = 'postgresql://user:pass@localhost:5432/mydb'
# pg_engine = sa.create_engine(pg_url)
# From environment variable (safer)
# pg_engine = sa.create_engine(os.environ['DATABASE_URL'])
print(sqlite_engine)
print(type(sqlite_engine))Leggere una tabella con pd.read_sql_table()
pd.read_sql_table('table_name', con=engine) legge un'intera tabella del database in un DataFrame. Inferisce automaticamente i tipi delle colonne dallo schema del database: gli interi rimangono interi, i timestamp diventano datetime e così via. È più preciso rispetto all'inferenza da CSV. Può anche limitare le colonne con l'argomento columns e filtrare le righe con schema per gli schemi del database non predefiniti. Presti attenzione alle tabelle molto grandi: questa operazione carica tutto nella RAM.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Read a full table
df = pd.read_sql_table('orders', con=engine)
print(df.shape)
print(df.dtypes)
print(df.head())Eseguire query con pd.read_sql_query()
pd.read_sql_query('SELECT ...', con=engine) esegue un'istruzione SQL SELECT arbitraria e restituisce i risultati come DataFrame. È l'approccio più flessibile: può filtrare, eseguire join e aggregare i dati in SQL prima di caricarli in Pandas, caricando solo le righe e le colonne necessarie. Scriva la query come una normale stringa Python. Non concateni mai input dell'utente nelle query: usi query parametrizzate per prevenire l'iniezione SQL.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
query = '''
SELECT customer_id, SUM(amount) AS total_spent,
COUNT(*) AS num_orders
FROM orders
WHERE status = 'completed'
GROUP BY customer_id
ORDER BY total_spent DESC
LIMIT 100
'''
top_customers = pd.read_sql_query(query, con=engine)
print(top_customers.head())Query parametrizzate per la sicurezza
Non costruisca mai query SQL concatenando stringhe con valori forniti dall'utente: ciò introduce vulnerabilità di tipo SQL injection. Usi invece query parametrizzate: passi i parametri come dizionario con segnaposto denominati. SQLAlchemy gestisce l'escape. La sintassi dei segnaposto è :name nelle query di testo SQLAlchemy oppure %(name)s per le query nello stile di psycopg2. Usi sempre la parametrizzazione, anche negli script interni, per acquisire buone pratiche.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Safe: parameterised query
params = {'status': 'completed', 'min_amount': 500.0}
query = sa.text(
'SELECT * FROM orders WHERE status = :status AND amount > :min_amount'
)
with engine.connect() as conn:
df = pd.read_sql_query(query, con=conn, params=params)
print(f'Loaded {len(df)} rows')Gestire in blocchi i risultati di query di grandi dimensioni
Per risultati di query di grandi dimensioni, usi chunksize in pd.read_sql_query() per ricevere un iteratore di DataFrame invece di caricare tutto in una sola volta. Questo ricalca il comportamento di pd.read_csv(chunksize=...), ma recupera le righe dal database in batch. Combini questa tecnica con un accumulatore progressivo per aggregare i risultati di query con milioni di righe senza esaurire la RAM.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('postgresql://user:pass@host/db')
total = 0.0
count = 0
for chunk in pd.read_sql_query(
'SELECT amount FROM orders',
con=engine,
chunksize=50000
):
total += chunk['amount'].sum()
count += len(chunk)
print(f'Mean amount: {total/count:.2f}')Gestori di contesto per le connessioni
Apra sempre le connessioni al database all'interno di un gestore di contesto (with engine.connect() as conn:) per garantire che la connessione venga chiusa correttamente anche se si verifica un'eccezione. Dimenticare di chiudere le connessioni porta all'esaurimento del pool di connessioni in produzione, causando il blocco delle nuove query in attesa di uno slot libero. Il pool di connessioni di SQLAlchemy gestisce un numero fisso di connessioni e le ricicla automaticamente quando si usano i gestori di contesto.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Using context manager — connection always closed properly
with engine.connect() as conn:
df = pd.read_sql_query(
'SELECT * FROM products WHERE category = "Electronics"',
con=conn
)
print(f'Products loaded: {len(df)}')
# Connection is automatically returned to the pool hereIspezionare lo schema del database
Prima di scrivere le query, deve sapere quali tabelle e colonne esistono. Inspector di SQLAlchemy consente di riflettere lo schema del database senza scrivere SQL grezzo. inspector.get_table_names() elenca tutte le tabelle; inspector.get_columns('table') restituisce i nomi e i tipi delle colonne. È utile quando lavora con database che non conosce e più ordinato rispetto all'esecuzione manuale di PRAGMA table_info() o \d tablename.
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
inspector = sa.inspect(engine)
# List all tables
tables = inspector.get_table_names()
print('Tables:', tables)
# Get columns for the 'orders' table
for col in inspector.get_columns('orders'):
print(f' {col["name"]}: {col["type"]}')Chiudere i motori e buone pratiche
Negli script di lunga durata o nelle applicazioni web, chiami engine.dispose() al termine del lavoro per chiudere tutte le connessioni del pool. Negli script brevi, il garbage collector di Python gestisce la pulizia. Buone pratiche per le connessioni al database nelle pipeline di dati: crei il motore una sola volta all'inizio dello script e lo riutilizzi; usi i valori predefiniti del pool (pool_size=5); abiliti pool_pre_ping=True per riconnettersi automaticamente se il server del database si riavvia tra una query e l'altra.
import sqlalchemy as sa
# Production-grade engine creation
engine = sa.create_engine(
'postgresql://user:pass@host:5432/mydb',
pool_size=5, # max 5 persistent connections
max_overflow=10, # allow 10 temporary extra connections
pool_pre_ping=True, # verify connection before use
connect_args={'connect_timeout': 10}
)
# ... run all your queries ...
# At the end of the application/script
engine.dispose()
print('Engine disposed')Confrontare la velocità di read_sql e read_csv
Per dati già presenti in un database con indici appropriati, pd.read_sql_query con una query filtrata è spesso più veloce dell'esportazione in CSV seguita dalla lettura. Il server del database applica i filtri prima di inviare i dati, riducendo il trasferimento in rete e il sovraccarico dell'analisi sintattica. Per le tabelle molto larghe, il database può inoltre selezionare solo le colonne necessarie. Tuttavia, la lettura da un database remoto tramite una rete lenta può essere più lenta della lettura di un file Parquet locale: misuri sempre le prestazioni di entrambe le opzioni nella Sua configurazione specifica.
import pandas as pd
import sqlalchemy as sa
import time
engine = sa.create_engine('sqlite:///data.db')
# Database read with server-side filter
start = time.time()
df_sql = pd.read_sql_query(
'SELECT * FROM transactions WHERE amount > 100 AND year = 2024',
con=engine
)
print(f'SQL read: {time.time()-start:.3f}s, {len(df_sql):,} rows')Verifica rapida
Verifichi la Sua comprensione dei concetti di analisi dei dati presentati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che sa.create_engine() crea una factory di connessioni riutilizzabile a partire da una stringa URL, pd.read_sql_query() esegue SQL arbitrario e restituisce un DataFrame, mentre le query parametrizzate con sa.text() e params prevengono le vulnerabilità di tipo SQL injection. Nel prossimo capitolo vedremo come eseguire query SQL più complesse da Pandas e combinare SQL con la logica Python.
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 «Connettersi a un database con SQLAlchemy» è gratuita?
Sì — il testo completo di «Connettersi a un database con SQLAlchemy» è 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 «Connettersi a un database con SQLAlchemy»?
Crei un engine SQLAlchemy per SQLite e PostgreSQL e lo passi a pd.read_sql per caricare una tabella in un DataFrame. 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 «Connettersi a un database con SQLAlchemy»?
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
- Connettersi a un database con SQLAlchemy
- Eseguire query SQL da Pandas
- Scrivere DataFrame nelle tabelle del database
- Pandas o SQL: scegliere lo strumento giusto