Soluzione

Codice Python

import pandas as pd

# Importa il file CSV
df = pd.read_csv('dati.csv')

# Mostra le prime 5 righe
print(df.head())
      

Spiegazione

pd.read_csv() è la funzione principale per importare dati da file CSV.

Il risultato è un DataFrame, la struttura dati principale di Pandas.

head() mostra le prime 5 righe (per un’anteprima dei dati).

Teoria

I CSV (Comma-Separated Values) sono tra i formati più comuni per lo scambio di dati tabulari. Pandas può gestire automaticamente:

• Intestazioni delle colonne
• Separatori (anche diversi dalla virgola)
• Tipi di dati diversi

Soluzione

Codice Python

import pandas as pd

df = pd.read_csv('dati2.csv',
                 sep=';',
                 header=None,
                 names=['id', 'nome', 'valore'],
                 skiprows=2)

print(df.head())
      

Spiegazione

sep specifica il separatore di campo.

header=None indica che non ci sono intestazioni nel file.

names assegna i nomi alle colonne.

skiprows salta le prime n righe.

Teoria

Pandas offre numerosi parametri per read_csv() per gestire casi speciali:

• encoding per file con codifiche diverse (es. ‘latin1’, ‘utf-8’)
• na_values per specificare come identificare valori mancanti
• dtype per forzare tipi di dati specifici

Soluzione

Codice Python

import pandas as pd

# Per leggere un singolo foglio
vendite = pd.read_excel('report.xlsx', sheet_name='Vendite')
print("DataFrame Vendite:")
print(vendite.head())

# Per leggere tutti i fogli in un dizionario di DataFrame
tutti_fogli = pd.read_excel('report.xlsx', sheet_name=None)

# Accedo ai fogli specifici
clienti = tutti_fogli['Clienti']
print("\nDataFrame Clienti:")
print(clienti.head())
      

Spiegazione

pd.read_excel() legge file Excel (.xlsx, .xls).

sheet_name specifica quale foglio leggere (nome o indice).

Con sheet_name=None si ottiene un dizionario con tutti i fogli.

Teoria

L’importazione da Excel richiede le librerie openpyxl o xlrd (da installare separatamente). Excel può contenere:

• Formattazione delle celle
• Formule
• Multipli fogli di lavoro

Pandas importa solo i dati, non la formattazione.

Soluzione

Codice Python

import pandas as pd
import json

# Opzione 1: Usare read_json (funziona bene per JSON semplici o con struttura 'records')
# df_simple = pd.read_json('dati.json', orient='records')
# print("Importazione con read_json (potrebbe richiedere manipolazioni successive per annidamenti):")
# print(df_simple)

# Opzione 2: Usare json_normalize per appiattire strutture annidate (più potente)
with open('dati.json') as f:
    data = json.load(f)

# Normalizza l'elenco di prodotti e le loro specifiche
df_normalized = pd.json_normalize(data['prodotti'])

print("Importazione con json_normalize (struttura annidata appiattita):")
print(df_normalized)
      

Spiegazione

read_json funziona bene con JSON semplici o strutture specifiche (come ‘records’).

Per strutture annidate complesse, json_normalize è più appropriato.

Prima si carica il JSON con il modulo json, poi si normalizza specificando il percorso ([`’prodotti’`] in questo caso) che contiene gli item da trasformare in righe.

Teoria

JSON (JavaScript Object Notation) è un formato leggero per lo scambio di dati. Può avere:

• Strutture annidate complesse (oggetti dentro oggetti)
• Array di oggetti
• Tipi di dati eterogenei

json_normalize aiuta ad appiattire strutture annidate in tabelle (DataFrame), creando colonne dai campi degli oggetti annidati (es. “specifiche.peso”, “specifiche.dimensioni”).

Soluzione

Codice Python (Usando sqlite3)

import pandas as pd
import sqlite3

# Crea una connessione al database (il file .db verrà creato se non esiste)
conn = sqlite3.connect('mydatabase.db')

# Esempio: crea una tabella fittizia e inserisci dati per il test
try:
    conn.execute('''
        CREATE TABLE IF NOT EXISTS utenti (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nome TEXT NOT NULL,
            eta INTEGER
        )
    ''')
    conn.execute("INSERT INTO utenti (nome, eta) VALUES ('Alice', 30)")
    conn.execute("INSERT INTO utenti (nome, eta) VALUES ('Bob', 25)")
    conn.commit()
except sqlite3.Error as e:
    print(f"Errore SQLite: {e}")

# Importa i dati con una query
query = "SELECT * FROM utenti"
df = pd.read_sql(query, conn)

# Mostra i dati
print("Dati dalla tabella 'utenti' (sqlite3):")
print(df)

# Chiudi la connessione
conn.close()
      

Codice Python (Usando SQLAlchemy – richiede `pip install sqlalchemy`)

import pandas as pd
from sqlalchemy import create_engine
import os # Per pulire il file db fittizio

# Rimuovi il database fittizio creato prima per un test pulito con SQLAlchemy
if os.path.exists('mydatabase.db'):
    os.remove('mydatabase.db')

# Crea un engine di connessione (il file .db verrà creato se non esiste)
# Formato URI: dialetto+driver://user:password@host:port/database
engine = create_engine('sqlite:///mydatabase.db')

# Esempio: crea una tabella fittizia e inserisci dati per il test usando Pandas to_sql
df_fittizio = pd.DataFrame({'nome': ['Charlie', 'David'], 'eta': [35, 28]})
try:
    df_fittizio.to_sql('utenti', engine, if_exists='replace', index=False)
except Exception as e:
     print(f"Errore SQLAlchemy to_sql: {e}")


# Importa i dati usando read_sql_table (più diretto se vuoi l'intera tabella)
# df = pd.read_sql_table('utenti', engine)

# ...oppure usando read_sql con una query (più flessibile)
query_sql = "SELECT * FROM utenti WHERE eta > 25"
df_sql = pd.read_sql(query_sql, engine)


# Mostra i dati
print("\nDati dalla tabella 'utenti' (SQLAlchemy con query):")
print(df_sql)

# Non serve chiudere l'engine esplicitamente per SQLite in questo caso
# engine.dispose() # Usare per engine più complessi
      

Spiegazione

Pandas può connettersi a database SQL.

sqlite3 è un modulo built-in in Python per database SQLite.

sqlite3.connect() crea una connessione al file del database.

pd.read_sql(query, connection) esegue la query SQL fornita sulla connessione data e restituisce un DataFrame.

È buona pratica chiudere la connessione al database con conn.close() quando non serve più.

SQLAlchemy è una libreria di astrazione (ORM) che offre un modo più uniforme per interagire con diversi tipi di database SQL.

create_engine() crea un oggetto engine che gestisce la connessione.

pd.read_sql_table('nome_tabella', engine) importa un’intera tabella.

pd.read_sql(query, engine) importa i risultati di una query usando l’engine SQLAlchemy.

Teoria

Pandas si integra con database SQL tramite:

• Connettori specifici per ogni tipo di DB (sqlite3 per SQLite, psycopg2 per PostgreSQL, mysql.connector per MySQL, etc. – spesso richiedono installazione separata).
• Librerie di astrazione come SQLAlchemy, che forniscono un’interfaccia comune indipendentemente dal DB sottostante.

read_sql è versatile e accetta sia query dirette che nomi di tabelle, ma la forma esatta può variare leggermente a seconda del motore DB e della libreria usata.

Soluzione

Codice Python

import pandas as pd
import io # Usato solo per simulare il file CSV in questo esempio

# Simula un file CSV con dati complessi
csv_data = """data,prodotto,prezzo,sconto
01-03-2023,Laptop,€1200.50,10%
15-03-2023,Tastiera,€75.00,5%
22-03-2023,Mouse,€25.99,0%
05-04-2023,Monitor,€350.75,15%
"""

# Definisci funzioni per pulire i dati
def clean_currency(val):
    # Assicura che val sia una stringa prima di chiamare .replace()
    if isinstance(val, str):
        return float(val.replace('€', '').strip())
    # Gestisci casi in cui il valore potrebbe non essere una stringa (es. NaN, None)
    return val

def clean_percent(val):
    # Assicura che val sia una stringa prima di chiamare .replace()
     if isinstance(val, str):
        return float(val.replace('%', '').strip()) / 100
     # Gestisci casi in cui il valore potrebbe non essere una stringa
     return val

# Importa il file CSV applicando i parametri di preprocessing
# Usiamo io.StringIO per leggere dalla stringa, nella realtà useresti il nome del file
df = pd.read_csv(io.StringIO(csv_data),
                 converters={
                     'prezzo': clean_currency,
                     'sconto': clean_percent
                 },
                 parse_dates=['data'], # Colonna 'data' da parsare come date
                 dayfirst=True)       # Specifica che il giorno è prima del mese

# Mostra i tipi di dati per verificare le conversioni
print("Tipi di dati dopo l'importazione e preprocessing:")
print(df.dtypes)

# Mostra il DataFrame risultante
print("\nDataFrame dopo preprocessing:")
print(df)
      

Spiegazione

converters è un dizionario dove le chiavi sono i nomi delle colonne e i valori sono funzioni da applicare a ciascun valore della rispettiva colonna durante l’importazione.

Le funzioni clean_currency e clean_percent rimuovono i simboli non numerici (€ e %) e convertono il valore in float. Per la percentuale, dividono anche per 100.

parse_dates=['data'] dice a Pandas di tentare di convertire i valori nella colonna ‘data’ in oggetti datetime.

dayfirst=True è un parametro di parse_dates che aiuta Pandas a interpretare correttamente i formati data ambigui, specificando che il giorno precede il mese (es. 01-03-2023 è 1 Marzo, non 3 Gennaio).

df.dtypes mostra i tipi di dati inferiti o convertiti per ciascuna colonna del DataFrame risultante.

Nell’esempio Python fornito, ho usato io.StringIO(csv_data) per leggere da una stringa che simula il contenuto del file, ma in un caso reale useresti semplicemente 'dati_complessi.csv' come primo argomento di pd.read_csv().

Teoria

Per lavorare con dati reali, il passaggio di importazione spesso include un’iniziale fase di pulizia e trasformazione (preprocessing):

• Pulizia: Rimuovere caratteri non necessari, gestire spazi bianchi extra (.strip()).
• Conversione di Tipo: Assicurarsi che le colonne numeriche, booleane o di data/ora siano rappresentate correttamente. Pandas inferisce i tipi di dati, ma non sempre è accurato, specialmente con simboli extra o formati data non standard.
• Gestione Valori Mancanti: Se necessario, specificare quali stringhe rappresentano valori mancanti (parametro na_values di read_csv).

Pandas fornisce molti strumenti integrati per facilitare queste operazioni già durante l’importazione o subito dopo.