Esempi Python pratici per iniziare con codice, file e SQLite

Quando un programma deve leggere dati, automatizzare un’attività o collegarsi a un database, Python permette di arrivare rapidamente a un risultato concreto. In questa guida raccolgo esempi del linguaggio Python per capire sintassi, strutture dati, funzioni, automazione e operazioni CRUD con SQLite, mostrando anche gli errori che rallentano più spesso chi sta imparando.

Perché Python è efficace negli esempi pratici

Python è un linguaggio general purpose, quindi può essere usato per script, applicazioni web, analisi dati, intelligenza artificiale e gestione dei database. La sua forza non sta solo nella sintassi breve, ma nella possibilità di risolvere un problema reale con poche righe leggibili.

La prima regola da capire è l’indentazione. In Python gli spazi definiscono i blocchi di codice, perciò non servono parentesi graffe come in altri linguaggi. Quattro spazi sono lo standard più usato.

nome = "Laura"
ore_lavorate = 8

if ore_lavorate >= 8:
    print(f"{nome} ha completato la giornata")
else:
    print(f"{nome} deve ancora lavorare")

La f-string inserisce una variabile direttamente nel testo e rende l’output più leggibile. Personalmente la preferisco alla concatenazione manuale, perché riduce gli errori quando una frase contiene numeri e valori di tipo diverso.

Variabili e tipi di dato

Le variabili non richiedono una dichiarazione esplicita del tipo. Python riconosce automaticamente se il valore è una stringa, un intero, un numero decimale o un valore booleano.

prodotto = "Tastiera"
prezzo = 49.90
disponibile = True
quantita = 3

totale = prezzo * quantita

print(prodotto)
print(f"Totale: {totale:.2f} euro")
print(f"Disponibile: {disponibile}")

Il formato :.2f mostra il prezzo con due cifre decimali. In applicazioni finanziarie più delicate, però, non userei direttamente i numeri floating point per i calcoli monetari, ma il tipo Decimal, che limita gli errori di arrotondamento.

Liste, dizionari e funzioni con esempi chiari

Le liste sono adatte quando abbiamo una sequenza ordinata di elementi. I dizionari, invece, collegano una chiave a un valore e sono spesso la scelta migliore per rappresentare un record, una configurazione o una risposta proveniente da un’API.

prodotti = [
    {"nome": "Mouse", "prezzo": 19.90},
    {"nome": "Monitor", "prezzo": 179.00},
    {"nome": "Webcam", "prezzo": 59.50}
]

costosi = [
    prodotto for prodotto in prodotti
    if prodotto["prezzo"] > 50
]

for prodotto in costosi:
    print(prodotto["nome"])

La sintassi usata nell’ultimo blocco si chiama list comprehension. È utile per creare una nuova lista applicando una regola, ma non va trasformata in una gara a scrivere tutto su una sola riga. Se la logica diventa complessa, un ciclo tradizionale è più facile da mantenere.

Funzioni riutilizzabili

Una funzione raccoglie un’operazione che può essere eseguita più volte. Questo evita duplicazioni e permette di testare ogni parte del programma in modo isolato.

def calcola_sconto(prezzo, percentuale):
    sconto = prezzo * percentuale / 100
    return prezzo - sconto

prezzo_finale = calcola_sconto(120, 15)
print(f"Prezzo finale: {prezzo_finale:.2f} euro")

Il comando return restituisce il risultato alla parte del programma che ha chiamato la funzione. Una buona funzione dovrebbe occuparsi di un compito preciso, avere nomi comprensibili e ricevere solo i dati di cui ha davvero bisogno.

Automatizzare file e attività ripetitive

Uno degli usi più concreti di Python è l’automazione. Rinominare documenti, filtrare righe di un CSV o generare un report sono attività semplici, ma possono richiedere molto tempo se ripetute manualmente.

from pathlib import Path

cartella = Path("documenti")

for file in cartella.glob("*.txt"):
    nuovo_nome = file.with_name(f"archivio_{file.name}")
    file.rename(nuovo_nome)
    print(f"Rinominato: {file.name}")

pathlib gestisce i percorsi in modo più sicuro e portabile rispetto alla costruzione manuale di stringhe. Prima di eseguire uno script di questo tipo su molti file, farei sempre una prova su una copia della cartella, perché un errore nel percorso può modificare numerosi documenti in pochi secondi.

Leggere un file CSV

Il formato CSV è comune nei gestionali e nei fogli di calcolo. Il modulo standard csv consente di leggerlo senza installare librerie aggiuntive.

import csv

with open("vendite.csv", newline="", encoding="utf-8") as file:
    lettore = csv.DictReader(file)

    for riga in lettore:
        cliente = riga["cliente"]
        importo = float(riga["importo"])
        print(f"{cliente}: {importo:.2f} euro")

L’istruzione with chiude automaticamente il file anche se durante la lettura si verifica un errore. La codifica UTF-8 è importante quando il documento contiene accenti o caratteri italiani.

Collegare Python a un database SQLite

Per imparare la programmazione e i database non serve iniziare da un’infrastruttura complessa. SQLite è incluso nella libreria standard di Python, salva tutto in un singolo file e va bene per prototipi, piccoli gestionali e strumenti locali.

import sqlite3

connessione = sqlite3.connect("negozio.db")
cursore = connessione.cursor()

cursore.execute("""
    CREATE TABLE IF NOT EXISTS prodotti (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nome TEXT NOT NULL,
        prezzo REAL NOT NULL
    )
""")

connessione.commit()
connessione.close()

La connessione apre il database e il cursore esegue le istruzioni SQL. Il comando commit() salva le modifiche, mentre close() libera la risorsa quando il lavoro è terminato.

Inserire, leggere e aggiornare dati

Le operazioni fondamentali sono chiamate CRUD, cioè creazione, lettura, modifica ed eliminazione dei dati. Per gli inserimenti è importante usare parametri separati dalla query, evitando di concatenare direttamente valori provenienti dall’utente.

import sqlite3

with sqlite3.connect("negozio.db") as connessione:
    cursore = connessione.cursor()

    cursore.execute(
        "INSERT INTO prodotti (nome, prezzo) VALUES (?, ?)",
        ("Cuffie", 39.90)
    )

    cursore.execute(
        "SELECT id, nome, prezzo FROM prodotti WHERE prezzo > ?",
        (30,)
    )

    prodotti = cursore.fetchall()

    for prodotto in prodotti:
        print(prodotto)

Il punto interrogativo è un segnaposto parametrizzato. Oltre a rendere il codice più ordinato, riduce il rischio di SQL injection, cioè l’inserimento di istruzioni SQL non autorizzate attraverso dati immessi dall’esterno.

Leggi anche: SQL Server Agent, come creare job affidabili

Modificare ed eliminare un record

with sqlite3.connect("negozio.db") as connessione:
    cursore = connessione.cursor()

    cursore.execute(
        "UPDATE prodotti SET prezzo = ? WHERE nome = ?",
        (34.90, "Cuffie")
    )

    cursore.execute(
        "DELETE FROM prodotti WHERE nome = ?",
        ("Cuffie",)
    )

In un’applicazione reale aggiungerei sempre una condizione precisa nella clausola WHERE. Un DELETE o un UPDATE senza filtro può modificare l’intera tabella, un errore banale ma potenzialmente costoso.

Quando usare SQLite e quando scegliere un database server

SQLite è eccellente per un’applicazione locale o per un progetto con pochi accessi contemporanei. Non è però la scelta ideale quando molti utenti devono scrivere dati nello stesso momento o quando servono gestione avanzata dei permessi, replica e alta disponibilità.

Il passaggio a PostgreSQL o MySQL richiede una libreria di connessione e una configurazione separata, ma la logica di base resta simile. In entrambi i casi conviene separare connessione, query e regole dell’applicazione, invece di mettere tutto dentro una singola funzione.

Per progetti più grandi si può usare un ORM, cioè uno strumento che rappresenta tabelle e righe con oggetti Python. È comodo per ridurre il codice SQL ripetitivo, ma non elimina la necessità di conoscere le query, gli indici e i costi delle operazioni.

Errori comuni negli esempi Python e come evitarli

Il primo errore tipico è ignorare l’ambiente virtuale. Crearne uno per ogni progetto evita che versioni diverse delle librerie si mescolino nello stesso sistema.

python -m venv .venv

# Linux e macOS
source .venv/bin/activate

# Windows
.venv\Scripts\activate

Un altro problema frequente riguarda la gestione delle eccezioni. Non userei un except generico per nascondere ogni errore, perché rende difficile capire che cosa non funziona.

try:
    numero = int(input("Inserisci un numero: "))
    risultato = 100 / numero
    print(risultato)
except ValueError:
    print("Inserisci un valore numerico valido")
except ZeroDivisionError:
    print("Il numero non può essere zero")

È meglio gestire solo gli errori prevedibili e lasciare visibili quelli inattesi. Durante lo sviluppo, un messaggio completo o un log è spesso più utile di una risposta generica come “si è verificato un problema”.

Infine, molti principianti copiano esempi funzionanti senza chiedersi quali siano i loro limiti. Un codice breve non è automaticamente robusto: bisogna considerare dati mancanti, input non validi, permessi sui file, concorrenza e dimensione del database.

Un percorso pratico per trasformare gli esempi in progetti

Il modo più efficace per imparare è modificare un esempio subito dopo averlo eseguito. Si può partire da un catalogo prodotti, aggiungere una ricerca, salvare i dati in SQLite e infine creare un piccolo report CSV.

• Scrivere una funzione che valida nome e prezzo.
• Salvare i prodotti in una tabella SQLite.
• Mostrare solo gli articoli sotto una determinata soglia.
• Calcolare il valore totale del catalogo.
• Esportare il risultato in un file CSV.

Questo tipo di esercizio mette insieme sintassi, strutture dati, funzioni, file e database senza introdurre troppi concetti contemporaneamente. È anche il punto in cui si capisce una cosa importante: Python si impara costruendo piccoli strumenti completi, non accumulando soltanto esempi isolati.

Per iniziare bastano Python, un editor di codice e un progetto concreto di dimensioni ridotte. Quando il programma cresce, si possono aggiungere test automatici, gestione dei log e un database server, mantenendo la stessa logica di base ma con maggiore disciplina progettuale.