5. Verifica del Setup

Per confermare che tutto funzioni, crea un nuovo file test.py nella cartella del tuo progetto. Scrivi la classica riga:

print("Ciao Mondo! Il mio setup Python funziona!")

Salva il file e, dal terminale (con l'ambiente virtuale attivo), eseguilo con: python test.py. Se vedi il messaggio in output, il tuo ambiente è pronto e funzionante.

Questo setup di base è solido, professionale e facilmente scalabile. Ora puoi concentrarti sull'apprendimento della sintassi e della logica di programmazione senza preoccupazioni tecniche.

Scaricare e installare Python (Windows, macOS, Linux)

Scaricare e installare Python (Windows, macOS, Linux)

Per iniziare a programmare in Python, il primo passo è installare l'interprete sul tuo sistema operativo. Il processo è semplice e gratuito, ma presenta alcune differenze tra Windows, macOS e Linux. Ecco una guida pratica per ogni piattaforma.

Installazione su Windows

Visita il sito ufficiale di Python (python.org) e scarica l'ultima versione stabile per Windows. Durante l'installazione, assicurati di selezionare l'opzione "Add Python to PATH": questo permette di eseguire Python da qualsiasi terminale. Dopo l'installazione, apri il Prompt dei comandi e digita python --version per verificare che tutto funzioni.

Installazione su macOS

Anche per macOS, il metodo più diretto è scaricare l'installer dal sito ufficiale di Python. Una volta scaricato il file .pkg, segui le istruzioni a schermo. Al termine, apri il Terminale e controlla la versione con python3 --version. Su macOS è comune che il comando python si riferisca a una versione precedente, quindi usa sempre python3.

Installazione su Linux

La maggior parte delle distribuzioni Linux include già Python preinstallato. Per aggiornarlo o installare una versione specifica, usa il gestore di pacchetti della tua distro. Ad esempio, su Ubuntu o Debian, puoi usare sudo apt update && sudo apt install python3. Su Fedora, invece, sudo dnf install python3. Dopo l'installazione, verifica sempre con python3 --version.

IDE e Editor di Testo: VS Code vs PyCharm vs Jupyter Notebook

IDE e Editor di Testo: VS Code vs PyCharm vs Jupyter Notebook

La scelta dell'ambiente di sviluppo (IDE) o editor di testo è fondamentale per programmare in Python in modo efficiente. Per i principianti del 2025, tre soluzioni dominano il mercato per caratteristiche e diffusione: Visual Studio Code, PyCharm e Jupyter Notebook. Ognuno ha pro e contro specifici a seconda del tuo obiettivo di apprendimento e del tipo di progetti che intendi affrontare.

• Visual Studio Code (VS Code): È un editor gratuito, leggero e estremamente versatile. Grazie alle sue estensioni (come Python o Pylint), si trasforma in un potente ambiente di sviluppo adatto a qualsiasi linguaggio. La curva di apprendimento è moderata e offre un eccellente bilanciamento tra semplicità e funzionalità avanzate, perfetto per chi inizia e vuole crescere.
• PyCharm: È un IDE dedicato specificamente a Python, disponibile in una versione Community (gratuita) e una Professional (a pagamento). Offre strumenti avanzati integrati per il refactoring, il debugging e il supporto per framework web. La versione gratuita è ottima per principianti, ma è più pesante di VS Code e meno flessibile per linguaggi alternativi.
• Jupyter Notebook: Non è un IDE tradizionale ma un ambiente interattivo basato su cellule di codice. È ideale per l'apprendimento esplorativo, il data science e per testare piccoli pezzi di codice in modo isolato. Rende immediato visualizzare risultati, grafici e documentazione (Markdown) nello stesso posto, ma è meno adatto per lo sviluppo di software complesso o progetti organizzati in file multipli.

Per un principiante che cerca un equilibrio, VS Code è spesso la raccomandazione più solida. PyCharm è la scelta eccellente se si intende focalizzarsi esclusivamente su Python fin dall'inizio. Jupyter Notebook rimane uno strumento specializzato ma potente per l'esplorazione dati e i progetti didattici. Provare più di uno strumento è il modo migliore per capire quale si adatta al tuo stile di apprendimento.

Verifica dell'installazione: Il primo "Hello World"

Sintassi di Base: I Mattoni del Codice

Sintassi di Base: I Mattoni del Codice

Prima di immergerti nei progetti più complessi, devi padroneggiare la grammatica fondamentale di Python. Come in qualsiasi lingua, imparare le regole di base è essenziale per comunicare chiaramente con il computer. In questa sezione, scomporremo i concetti fondamentali che costituiscono la struttura di ogni programma Python, passo dopo passo. Non ti chiederemo di memorizzare ogni dettaglio, ma di comprendere il perché dietro ogni regola, in modo da poter scrivere codice che funziona e che puoi leggere facilmente in futuro.

La sintassi di Python è progettata per essere leggibile e logica, riducendo al minimo il "rumore" visivo. Vedremo come dichiarare variabili, utilizzare i tipi di dati fondamentali e controllare il flusso del tuo programma con condizioni e cicli. Ogni concetto è un mattoncino che, una volta posto correttamente, ti permetterà di costruire soluzioni robuste per la tua azienda o per progetti personali, automatisando task o analizzando dati in modo efficace.

Variabili e Tipi di Dati

Le variabili sono contenitori che memorizzano informazioni. In Python, non devi dichiarare il tipo di una variabile esplicitamente; il linguaggio lo deduce automaticamente dal valore assegnato. Questo approccio semplifica molto la scrittura del codice.

Ecco i tipi di dati più comuni:

• Stringhe (str): Sequenze di caratteri, racchiuse tra virgolette singole (') o doppie ("). Es: nome = "Alice", messaggio = 'Il corso inizia oggi!'
• Interi (int): Numeri interi senza parte decimale. Es: eta = 30, quantita = 150
• Float (float): Numeri con parte decimale. Es: prezzo = 19.99, altezza = 1.75
• Booleani (bool): Valori che rappresentano vero (True) o falso (False). Es: is_active = True, is_paid = False
• Lista (list): Sequenza ordinata e mutabile di elementi. Es: lista_prodotti = ["lapto", "mouse", "tastiera"], lista_prezzi = [1200, 25, 50]

Operatori Fondamentali

Gli operatori sono simboli che ti permettono di eseguire operazioni matematiche, logiche o di confronto tra variabili. Li userai in ogni programma.

• Operatori Aritmetici: Per eseguire calcoli matematici.
  • + Addizione (5 + 3)
  • - Sottrazione (10 - 2)
  • * Moltiplicazione (4 * 6)
  • / Divisione (restituisce un float, 10 / 2 = 5.0)
  • // Divisione intera (restituisce solo la parte intera, 10 // 3 = 3)
  • % Resto della divisione (10 % 3 = 1)
  • ** Elevamento a potenza (2 ** 3 = 8)
• Operatori di Confronto: Confrontano due valori e restituiscono True o False.
  • == Uguale a
  • != Diverso da
  • > Maggiore di
  • < Minore di
  • >= Maggiore o uguale a
  • <= Minore o uguale a
• Operatori Logici: Combinano espressioni booleane.
  • and Restituisce True solo se entrambe le condizioni sono vere.
  • or Restituisce True se almeno una condizione è vera.
  • not Inverte il valore booleano (not True = False).

Strutture di Controllo

Le strutture di controllo dirigono il flusso di esecuzione del programma, permettendo di prendere decisioni o ripetere operazioni.

Istruzioni Condizionali (if, elif, else)

Le istruzioni condizionali permettono di eseguire blocchi di codice diversi in base a una condizione. Sono fondamentali per programmi che devono reagire a diverse situazioni.

eta = 25
if eta >= 18:
    print("Sei maggiorenne.")
elif eta >= 12:
    print("Sei un adolescente.")
else:
    print("Sei un minorenne.")

Nel codice sopra, Python verifica la prima condizione (eta >= 18). Se è vera, esegue il blocco if e salta il resto. Se non è vera, controlla elif. Se nessuna è vera, esegue il blocco else.

Cicli (for, while)

I cicli ripetono un blocco di codice finché una condizione è soddisfatta.

• Ciclo for (iterativo): Usato quando sai quante volte vuoi ripetere un'operazione o vuoi scorrere un elemento (come una lista). È il ciclo più comune in Python.

lista_clienti = ["Mario", "Lucia", "Giovanni"]
for cliente in lista_clienti:
    print(f"Invio email a: {cliente}")

• Ciclo while (condizionale): Ripete un blocco finché una condizione rimane vera. Utile per iterazioni di lunghezza non nota a priori.

contatore = 0
while contatore < 5:
    print(f"Contatore: {contatore}")
    contatore += 1  # Incremento di 1

Un uso comune è leggere file o dati da un database fino alla fine.

Funzioni

Le funzioni sono blocchi di codice riutilizzabili che eseguono un'azione specifica. Aiutano a organizzare il codice, ridurre le ripetizioni e migliorare la manutenibilità. In Python, definisci una funzione con def.

def calcola_imponibile(prezzo, iva=0.22):
    """
    Calcola l'imponibile partendo da un prezzo lordo.
    Parametri:
    - prezzo: float, il prezzo lordo.
    - iva: float, l'aliquota IVA (default 22%).
    """
    imponibile = prezzo / (1 + iva)
    return imponibile

# Esempio di utilizzo
prezzo_totale = 122.00
imponibile = calcola_imponibile(prezzo_totale)
print(f"Imponibile: € {imponibile:.2f}")  # Output: Imponibile: € 100.00

Questa funzione accetta due parametri: prezzo (obbligatorio) e iva (opzionale, con valore di default 0.22). Il risultato viene restituito con return.

Errori Comuni da Evitare

Quando impari la sintassi, alcuni errori ricorrenti possono bloccarti. Ecco i più comuni e come risolverli:

• Indentazione non corretta: In Python, l'indentazione definisce i blocchi di codice (dopo if, for, def, ecc.). Usa sempre 4 spazi (standard PEP 8). Un errore di indentazione causa un IndentationError.
• Collegare tipi di dati incompatibili: Non puoi sommare una stringa a un numero senza convertirlo esplicitamente. "Il prezzo è: " + 50 genererà un TypeError. Correggi con "Il prezzo è: " + str(50) o usando formattazione (f-string come nell'esempio sopra).
• Dimenticare i due punti (:): Le istruzioni if, for, while, def richiedono i due punti alla fine della riga.
• Dichiarare una variabile e usarla nello stesso momento (Scope): In Python, non puoi usare una variabile definita in un blocco if fuori da esso se la condizione era falsa. Assicurati che le variabili siano accessibili nel loro scope.
• Usare == invece di = per assegnazione: Un errore classico. if variabile = 5: è sintassi errata. Usa if variabile == 5: per confrontare.

Imparare a riconoscere questi errori è una parte fondamentale dello sviluppo. La pratica costante è la chiave per padroneggiare la sintassi. Inizia con piccoli script, testa ogni modificazione e usa l'ambiente di sviluppo per aiutarti a individuare i problemi rapidamente.

Commenti e PEP 8: Lo stile del codice Python

Commenti e PEP 8: Lo stile del codice Python

Scrivere codice funzionale è solo la metà del lavoro; renderlo leggibile per te e per altri è essenziale. In Python, lo stile è regolato da PEP 8, lo standard di stile ufficiale della comunità. Per commenti, usa # per spiegare il perché di una scelta, non il cosa (il codice stesso dovrebbe essere auto-esplicativo). Mantieni una larghezza di riga ragionevole (79 caratteri è il consiglio classico) e usa indentazioni coerenti (4 spazi, non tab).

Il rispetto di PEP 8 migliora la manutenibilità del codice, un vantaggio cruciale quando si lavora in team o su progetti di lunga durata. Adottare queste convenzioni da subito riduce il tempo di debug e facilita il passaggio di consegne. Un buon codice ben stilato è più facile da revisionare e integrare con altri sistemi, come API o framework.

Se stai sviluppando progetti complessi per la tua azienda, come script di automazione o integrazioni, lo stile coerente è fondamentale per la qualità. Per una guida pratica su come applicare questi principi nei tuoi progetti, richiedi una consulenza gratuita con i nostri esperti.

Variabili e Tipi di Dati fondamentali (int, float, str, bool)

Variabili e Tipi di Dati fondamentali (int, float, str, bool)

Una volta impostato l'ambiente di sviluppo, il primo concetto pratico da assimilare è la gestione delle variabili e dei tipi di dati. In Python, una variabile è un nome che riferisce a un valore memorizzato in memoria. La dichiarazione è semplice: si usa il nome seguito dal simbolo di assegnazione =. Ad esempio, nome_utente = "Mario Rossi" crea una variabile chiamata nome_utente contenente una stringa di testo.

Tipi di Dati Primitivi

Python utilizza tipi di dati dinamici, meaning che non devi dichiarare esplicitamente il tipo alla creazione; viene dedotto automaticamente. I quattro tipi fondamentali sono:

• Intero (int): Numeri interi, positivi o negativi, senza parte decimale. Esempio: età = 30, saldo = -150.
• Virgola mobile (float): Numeri con parte decimale, usati per calcoli di precisione. Esempio: pi = 3.14, prezzo = 19.99.
• Stringa (str): Sequenza di caratteri tra virgolette singole o doppie. Essenziale per testi, indirizzi email, messaggi. Esempio: messaggio = "Benvenuto nel corso!", insegna = 'Pasticceria Giulia'.
• Booleano (bool): Valori logici, solo True (vero) o False (falso). Cruciali per condizioni e controlli. Esempio: is_active = True, has_discount = False.

Operazioni di Base e Conversione

Comprendere come interagiscono questi tipi è fondamentale. Puoi sommare due numeri interi, ma sommare un intero a una stringa genera un errore. Per evitare problemi, Python offre funzioni per convertire i tipi: int(), float(), str(), bool(). Esempio: se anno = 2025 (int), anno_str = str(anno) lo trasforma in una stringa utile per la stampa.

Dagli script iniziali, si passa rapidamente a gestire dati complessi come liste di valori o dizionari per configurazioni. Per chi viene da un contesto PA o PMI, questa base è essenziale prima di programmare script per automazioni di report o integrazioni con CRM. Se il tuo obiettivo è applicare Python a scenari reali di azienda, un assessment mirato aiuta a identificare le funzioni più utili al tuo contesto.

Operatori aritmetici e logici

Operatori aritmetici e logici

Per gestire calcoli e condizioni, Python si affida a operatori essenziali. Gli operatori aritmetici esegucono operazioni matematiche fondamentali: + per l'addizione, - per la sottrazione, * per la moltiplicazione e / per la divisione (che restituisce sempre un float). Se hai bisogno di calcolare il resto di una divisione, usa l'operatore modulo %, mentre ** serve per le potenze.

Per le condizioni, ecco gli operatori logici principali:

• and: restituisce True solo se entrambe le condizioni sono vere.
• or: restituisce True se almeno una delle condizioni è vera.
• not: inverte il valore booleano, trasformando True in False e viceversa.

Questi strumenti sono la base per scrivere script che reagiscono a dati e input variabili. Per approfondire come applicarli in progetti reali, parla con i nostri esperti.

Type Hinting (Type Annotations) e controllo statico

Type Hinting (Type Annotations) e controllo statico

Il type hinting aggiunge annotazioni di tipo al codice Python per specificare che tipo di dati ci si aspetta per parametri, variabili e valori di ritorno di funzioni. In Python, non è obbligatorio e non viene controllato a runtime (non causa errori se i tipi non coincidono), ma è uno strumento fondamentale per migliorare la leggibilità, manutenibilità e la qualità del codice, specialmente in progetti complessi o di team.

Un esempio base:

def saluta(nome: str) -> str:
    return f"Ciao, {nome}"

Qui, nome: str indica che il parametro deve essere una stringa, mentre -> str specifica che la funzione deve restituire una stringa. Il principale vantaggio è il supporto degli IDE moderni: contestualizzano i suggerimenti, evidenziano errori di tipo evidenti e migliorano l'autocompletamento.

Per un controllo statico (che verifica i tipi senza eseguire il codice), si utilizzano strumenti come Mypy o Pyright. Questi scanner analizzano il codice e segnalano potenziali incompatibilità di tipo, come passare un intero dove è attesa una stringa, prima ancora di eseguire lo script. Integrare un controllo statico nel flusso di sviluppo (ad esempio, in CI/CD) è una pratica che riduce significativamente i bug e facilita il refactoring di codice legacy. È particolarmente utile in PA e PMI, dove il codice di progetti critici deve essere robusto e facilmente manutenibile da più sviluppatori.

Per cominciare, basta aggiungere le annotazioni alle funzioni esistenti e poi configurare uno strumento di controllo statico per verificare regolarmente il progetto.

Strutture Dati Fondamentali

Strutture Dati Fondamentali

Una delle prime decisioni quando si inizia a programmare in Python è capire quale struttura dati usare per immaginare e organizzare le informazioni. Python offre una serie di strutture dati integrate, semplici e potenti, che costituiscono il fondamento per qualsiasi applicazione, sia essa uno script per automatizzare un compito o un intero sistema gestionale.

Le strutture dati più comuni sono progettate per gestire diversi tipi di relazioni tra i dati: sequenze ordinate, collezioni non ordinate e coppie chiave-valore. Comprenderle non è un esercizio accademico, ma una necessità pratica: scegliere quella giusta riduce il tempo di sviluppo, migliora le prestazioni e rende il codice più leggibile e manutenibile. In questo capitolo esploriamo le strutture dati fondamentali di Python, con esempi pratici e consigli su quando usarle.

Liste: sequenze mutabili e ordinate

La lista è la struttura dati più versatile e utilizzata in Python. Rappresenta una sequenza ordinata di elementi, i quali possono essere di tipi diversi (numeri, stringhe, altre liste, ecc.). È mutabile, il che significa che puoi modificarla dopo la sua creazione: aggiungere, rimuovere o cambiare elementi. Per questo motivo è perfetta per collezioni di dati che cambiano nel tempo, come una lista di clienti, un inventario o i risultati di un calcolo iterativo.

# Creazione di una lista
clienti = ["Azienda Rossi", "Studio Bianchi", "Ditta Verdi"]

# Aggiungere un elemento
clienti.append("Negozio Neri")

# Accedere a un elemento (indice a partire da 0)
primo_cliente = clienti[0]  # "Azienda Rossi"

# Rimuovere un elemento
clienti.remove("Studio Bianchi")

print(clienti)  # Output: ['Azienda Rossi', 'Ditta Verdi', 'Negozio Neri']

Oltre alle operazioni di base, le liste offrono metodi potenti come sort() per ordinare, count() per contare occorrenze e extend() per unire due liste. Sono il punto di partenza per la gestione di sequenze di dati e sono fondamentali per implementare logiche di controllo e raccolta risultati nei processi automatizzati.

Tuple: sequenze immutabili

Le tuple sono simili alle liste in quanto sequenze ordinate di elementi, ma con una differenza cruciale: sono immutabili. Una volta create, non possono essere modificate. Questa caratteristica le rende ideali per dati che non devono cambiare, come le coordinate geografiche (latitudine, longitudine), le configurazioni di base o i periodi di tempo.

# Creazione di una tupla
coordinate = (45.4642, 9.1900)  # Milano

# Accesso agli elementi
latitudine = coordinate[0]  # 45.4642

# Tentativo di modifica (genera un errore)
# coordinate[0] = 46.0000  # TypeError: 'tuple' object does not support item assignment

L'immuabilità è un vantaggio per la stabilità del codice. Le tuple sono più efficienti in termini di memoria rispetto alle liste e possono essere usate come chiavi nei dizionari (le liste no). Rappresentano spesso punti fissi di un sistema, come le coordinate per la geolocalizzazione in un'app che analizza le prestazioni di negozi locali.

Dizionari: mappare chiavi a valori

I dizionari sono strutture dati che memorizzano coppie chiave-valore. Sono analoghi a un dizionario fisico o a un database in memoria, dove puoi cercare rapidamente un valore conoscendo la sua chiave. Le chiavi devono essere immutabili (stringhe, numeri, tuple), mentre i valori possono essere di qualsiasi tipo. Questa struttura è essenziale per organizzare dati strutturati e per accessi veloci senza dover scorrere l'intera collezione.

# Dizionario per configurazioni di un'app web
config = {
    "nome_app": "GestioneNegozi",
    "versione": "1.0",
    "database": "postgres",
    "api_key": "xyz123abc"
}

# Accesso a un valore
print(config["nome_app"])  # Output: GestioneNegozi

# Aggiungere una nuova configurazione
config["debug_mode"] = False

# Metodo get() per evitare errori se la chiave manca
db = config.get("database", "sqlite")  # Usa "sqlite" come default

Nei processi automatizzati, i dizionari sono utili per mantenere relazioni tra entità, come associare un codice cliente al suo record completo. Sono anche fondamentali per passare configurazioni dinamiche ai servizi di marketing automation o per strutturare i dati in uscita da un API.

Set: collezioni non ordinate e uniche

I set sono collezioni non ordinate di elementi unici. Non consentono duplicati e non supportano l'indicizzazione numerica. Sono ottimizzati per operazioni di insiemistica, come l'unione, l'intersezione e la differenza tra collezioni. In Python, sono mutabili, ma esiste una versione immutabile (frozenset) che può essere usata come chiave in un dizionario.

# Creazione di un set per rimuovere duplicati
parole_chiave = {"python", "automazione", "pa", "pmi", "python"}

print(parole_chiave)  # Output: {'automazione', 'pa', 'pmi', 'python'}

# Operazioni insiemistiche
altre_parole = {"automazione", "cybersecurity"}
intersezione = parole_chiave.intersection(altre_parole)  # {'automazione'}

I set sono utili per verificare l'appartenenza (membership test) di un elemento in una collezione. In un sistema di cybersecurity, un set può contenere gli indirizzi IP bloccati, permettendo un controllo rapido se un nuovo indirizzo è nella lista nera.

Quando usare quale struttura: una guida pratica

La scelta della struttura dati giusta dipende dalle operazioni che dovrai svolgere più frequentemente. Ecco una checklist decisionale:

• Usa una lista se: hai bisogno di una sequenza ordinata di elementi e devi poterla modificare (aggiungere, rimuovere, ordinare). Esempio: passo di una workflow di automazione, serie di dati da elaborare.
• Usa una tupla se: hai una collezione di dati che non deve cambiare. Esempio: parametri di configurazione fissi, coordinate geografiche, elementi di un menu di navigazione in un'interfaccia web.
• Usa un dizionario se: hai bisogno di associare a una chiave un valore per un accesso rapido. Esempio: configurazioni di un'app, mappatura di ID a descrizioni, dati strutturati in un report.
• Usa un set se: ti serve una collezione di elementi unici e vuoi controllare rapidamente se un elemento è presente o fare operazioni di insiemi. Esempio: lista di contatti da evitare, parole chiave per un filtro, diritti di accesso di un utente.

Queste scelte hanno un impatto diretto sulle performance e sulla manutenibilità del codice. In progetti di digitalizzazione per PA e PMI, dove la gestione di documenti, clienti e configurazioni è centrale, l'uso consapevole di queste strutture è il primo passo per un sistema robusto e scalabile.

Una volta padroneggiate le strutture dati di base, potrai passare a strutture più complesse come liste di dizionari, dizionari annidati o implementare strutture dati personalizzate per casi d'uso specifici. La chiave è iniziare semplice e scegliere lo strumento giusto per il compito.

Liste: Creazione, slicing e metodi principali

Creazione di liste in Python

Le liste in Python sono collezioni ordinate e mutabili di elementi. Per crearne una nuova, puoi usare la sintassi con parentesi quadre, contenendo gli elementi separati da virgole. Ad esempio, lista_vuota = [] crea una lista senza elementi, mentre lista_numeri = [1, 2, 3] inizializza una lista con tre interi.

Un'altra modalità comune è utilizzare il costruttore list(), passando un iterable come argomento. Per esempio, lista_stringhe = list(("primo", "secondo")) genera una lista a partire da una tupla.

Accesso e Slicing (taglio)

Gli elementi di una lista si recuperano tramite il loro indice, partendo da 0. lista_numeri[0] restituisce il primo elemento (1), mentre lista_numeri[-1] restituisce l'ultimo (3).

Lo slicing permette di estrarre sottosequenze usando la sintassi lista[start:stop:step]. Per esempio, lista_numeri[0:2] restituisce [1, 2] (da start a stop-1). Lasciare start o stop vuoto indica rispettivamente l'inizio o la fine della lista. Lo step negativo inverte l'ordine: lista_numeri[::-1] produce [3, 2, 1].

Metodi principali delle liste

• append(elemento): Aggiunge un elemento alla fine della lista (lista.append(4) -> [1, 2, 3, 4]).
• insert(indice, elemento): Inserisce un elemento in una posizione specifica (lista.insert(1, 99) -> [1, 99, 2, 3]).
• remove(elemento): Rimuove la prima occorrenza del valore specificato (lista.remove(2) -> [1, 3]).
• pop(indice): Rimuove e restituisce l'elemento all'indice specificato. Se omesso, rimuove l'ultimo (lista.pop() -> 3).
• sort(): Ordina la lista in loco. Può accettare un parametro reverse=True per l'ordinamento decrescente.
• reverse(): Inverte l'ordine degli elementi direttamente nella lista.
• len(): Funzione integrata che restituisce il numero di elementi nella lista.
• count(elemento): Conta quante volte un elemento appare nella lista.

Queste operazioni fondamentali ti permettono di manipolare efficacemente le strutture dati più comuni in Python, indispensabili per gestire input, dati temporanei e risultati di calcoli in qualsiasi applicazione, dalla semplice automazione di script alla gestione di dataset per analisi più complesse.

Tuple: Liste immutabili e casi d'uso

Definizione e differenze dalle liste

Le tuple sono collezioni ordinate di elementi, simili alle liste, ma con una differenza fondamentale: sono immutabili. Una volta create, non possono essere modificate (non puoi aggiungere, rimuovere o cambiare elementi). La sintassi è semplice: gli elementi sono racchiusi tra parentesi tonde (1, 2, 3), non quadrate. Per definire una tupla con un solo elemento, è necessario aggiungere una virgola finale, ad esempio (5,).

Perché usare le tuple?

L'immutabilità offre due vantaggi principali:

• Sicurezza: Garantisce che i dati non vengano alterati accidentalmente. È ideale per costanti o dati di configurazione che non devono cambiare durante l'esecuzione del programma.
• Performance: Le tuple sono leggermente più veloci delle liste e utilizzano meno memoria, poiché il loro contenuto è fisso.

Casi d'uso pratici

Ecco alcuni scenari tipici dove le tuple sono preferibili alle liste:

• Dati fissi di configurazione: Come coordinate GPS (latitudine, longitudine) o parametri di un database (host, porta, utente).
• Valori di ritorno di funzioni: Quando una funzione deve restituire più valori, è convenzione usare una tupla (es. return nome, cognome, età).
• Chiavi nei dizionari: Le chiavi nei dizionari devono essere immutabili. Le tuple sono perfette per chiavi complesse, come coppie (città, anno).
• Elementi di un set: Similmente, gli elementi di un set devono essere immutabili. Puoi usare tuple per memorizzare record univoci.
• Iterazione sicura: Se hai una collezione di dati che non devi modificare, iterare su una tupla è una scelta esplicita che segnala questa intenzione nel codice.

Per organizzare meglio i tuoi dati, in special modo se devi gestire configurazioni o record strutturati, potresti considerare una struttura più definita. Culture Digitali offre consulenza nella progettazione di strutture dati e architetture software che garantiscono efficienza e manutenibilità.

Se stai esplorando la programmazione per automatizzare processi aziendali o analizzare dati, l'approccio strutturato è fondamentale. Potremo aiutarti a tradurre le tue esigenze in uno schema dati robusto.

Dizionari (Dictionary): Coppie chiave-valore e gestione dati

Dizionari (Dictionary): Coppie chiave-valore e gestione dati

I dizionari in Python sono strutture dati fondamentali per organizzare informazioni in coppie chiave-valore. A differenza delle liste, dove l'accesso avviene tramite indice numerico, i dizionari utilizzano chiavi univoche (che possono essere stringhe, numeri o altri tipi immutabili) per recuperare i valori associati in modo estremamente efficiente.

Come creare un dizionario

Puoi creare un dizionario vuoto con la sintassi dict = {} oppure inizializzarlo direttamente con dati:

utente = {
    "nome": "Mario",
    "età": 30,
    "città": "Milano"
}

Ogni elemento è separato da una virgola, e la coppia chiave-valore è definita da chiave: valore.

Operazioni di base

• Accesso a un valore: nome_utente = utente["nome"]
• Modifica di un valore: utente["età"] = 31
• Aggiunta di un nuovo elemento: utente["email"] = "mario@example.com"
• Cancellazione di un elemento: del utente["città"]
• Verifica esistenza chiave: if "email" in utente:

Se provi ad accedere a una chiave inesistente, Python solleva un'eccezione KeyError. Per evitare errori, usa il metodo .get(), che restituisce None (o un valore di default) se la chiave non esiste: email = utente.get("email").

Metodi utili per la gestione dei dati

I dizionari offrono metodi pratici per la manipolazione dei dati:

• .keys(): restituisce un oggetto con tutte le chiavi.
• .values(): restituisce un oggetto con tutti i valori.
• .items(): restituisce una coppia di chiave-valore per ogni elemento, utile per ciclare il dizionario con un for.

for chiave, valore in utente.items():
    print(f"{chiave}: {valore}")

Casi d'uso pratici

I dizionari sono ideali per rappresentare configurazioni, dati di database o risultati di API. Per esempio, puoi creare un dizionario di dizionari per gestire un catalogo di prodotti, dove ogni prodotto è identificato da un codice unico (chiave) e contiene un altro dizionario con nome, prezzo e quantità.

Questa struttura rende agile l'aggiornamento dei dati senza dover ricercare per posizione, accelerando lo sviluppo di funzionalità come filtri, ricerche e statistiche.

Set: Unicità e operazioni insiemistiche

I set sono collezioni non ordinate di elementi unici. In Python, un set non ammette duplicati: se provi ad aggiungere un elemento già presente, l'operazione viene ignorata. Questo li rende ideali per pulire dataset, gestire liste di ID o calcolare elementi distinti rapidamente.

Puoi creare un set con { } o set(), ma non con i [ ] (quelli sono liste). Le operazioni chiave sono:

• add() per un elemento singolo
• update() per aggiungere più elementi da una lista
• remove() o discard() per cancellare; il primo solleva un errore se manca, il secondo no

Le operazioni insiemistiche sono potenti: union() (o |) unisce due set, intersection() (o &) restituisce gli elementi comuni, difference() (o -) toglie quelli presenti nell'altro. symmetric_difference() (o ^) restituisce gli elementi in uno o nell'altro, ma non in entrambi.

Attenzione: gli elementi di un set devono essere immutabili (stringhe, numeri, tuple). Liste e altri set non sono ammessi.

Controllo del Flusso: Logica e Decisioni

Controllo del Flusso: Logica e Decisioni

Il cuore di ogni programma risiede nella capacità di prendere decisioni e di ripetere azioni. Senza questa logica, un codice si limita a eseguire istruzioni in sequenza, come una ricetta di cucina scritta una sola volta. In Python, il controllo del flusso ti permette di costruire programmi dinamici, che reagiscono a condizioni diverse e gestiscono grandi quantità di dati in modo efficiente.

Le istruzioni condizionali: if, elif, else

L'istruzione condizionale fondamentale è if. Valuta una condizione (che restituisce True o False) ed esegue un blocco di codice solo se la condizione è vera. Puoi estendere la logica con elif (per più condizioni) e else (per il caso di default).

temperatura = 30
if temperatura > 25:
    print("È caldo, attiva il climatizzatore.")
elif temperatura < 10:
    print("Fa freddo, accendi il riscaldamento.")
else:
    print("Temperatura nelle norme.")

Consiglio pratico: Mantieni i blocchi if/elif/else il più possibile semplici. Se la logica diventa troppo annidata, valuta di suddividerla in funzioni separate.

Operatore logico: and, or, not

Per combinare più condizioni, usa gli operatori logici. and richiede che tutte le condizioni siano vere. or richiede che almeno una sia vera. not inverte il valore booleano.

età = 18
ha_tessera = True

if età >= 18 and ha_tessera:
    print("Accesso permesso.")
else:
    print("Accesso negato.")

I cicli: while e for

I cicli permettono di ripetere un blocco di codice finché una condizione è soddisfatta (while) o per ciascun elemento in una sequenza (for).

Ciclo while

Utile quando non conosciamo in anticipo il numero di iterazioni. Attenzione: per evitare cicli infiniti, assicurati che la condizione diventi False a un certo punto.

contatore = 0
while contatore < 5:
    print(f"Contatore: {contatore}")
    contatore += 1  # Incrementa il valore

Ciclo for

È il ciclo più comune in Python. Itera su una sequenza (lista, stringa, range).

nomi = ["Alice", "Bob", "Charlie"]
for nome in nomi:
    print(f"Ciao, {nome}!")

# Iterare su un range numerico
for numero in range(1, 6):
    print(numero)

Controllo del flusso con break e continue

break esce immediatamente dal ciclo, interrompendo l'iterazione. continue salta l'iterazione corrente e passa alla successiva.

for numero in range(10):
    if numero % 2 == 0:  # Se il numero è pari
        continue        # Salta l'istruzione sottostante per i pari
    print(numero)       # Stampa solo i numeri dispari

Questi strumenti offrono un controllo granulare sull'esecuzione del programma, permettendoti di gestire scenari complessi in modo elegante.

Statement condizionali: if, elif, else

Statement condizionali: if, elif, else

I statement condizionali sono il fondamento della logica di programmazione in Python. Ti permettono di eseguire blocchi di codice diversi a seconda che una determinata condizione sia vera o falsa. Il costrutto principale è l'istruzione if. Se la condizione dopo if è True, il codice nel blocco sottostante viene eseguito.

Per gestire casi alternativi, si usa elif (contrazione di "else if"). Python valuta le condizioni in ordine: la prima che risulta vera farà eseguire il suo blocco di codice e poi saltará tutte le restanti. Al termine, puoi aggiungere un blocco else che viene eseguito solo se nessuna delle condizioni precedenti è vera.

Ecco un esempio pratico per un'azienda che gestisce ordini:

import datetime

# Simula l'orario di invio di un ordine
ora_invio = 16  # utilizziamo un formato 24h

if ora_invio < 12:
    print("Spedizione prevista per stamattina.")
elif ora_invio < 18:
    print("Spedizione prevista per questo pomeriggio.")
else:
    print("L'ordine sarà elaborato domani mattina.")

Questo approccio logico è essenziale per automatizzare decisioni in qualsiasi sistema, come un CRM o un'applicazione di gestione inventari.

Cicli e iterazioni: For e While loop

For Loop: Lavorare su sequenze

Il ciclo for in Python itera su una sequenza (lista, stringa, tupla) o qualsiasi oggetto iterabile. È la scelta preferita quando sai quante volte vuoi ripetere un'operazione o devi processare ogni elemento di una collezione.

Esempio pratico: per stampare ogni elemento di una lista di nome software:

software = ["CRM", "EDR", "DMS"]
for tool in software:
    print(f"Strumento: {tool}")

Nel contesto della digitalizzazione PMI, potresti usare un ciclo for per analizzare i log di sicurezza o per processare in batch documenti dematerializzati.

While Loop: Esecuzione basata su condizione

Il ciclo while esegue un blocco di codice finché una condizione specifica rimane vera. È utile quando non conosci a priori il numero esatto di iterazioni necessarie, ad esempio in un'automazione di processi dove devi attendere un input o verificare uno stato.

contatore = 0
while contatore < 5:
    print(f"Processo in esecuzione: {contatore}")
    contatore += 1

Usalo con attenzione per evitare cicli infiniti; assicurati che la condizione possa diventare falsa.

Scegliere tra For e While

• For Loop: Ideale per iterare su collezioni note o per un numero fisso di cicli.
• While Loop: Adatto a scenari dinamici, dove l'uscita dipende da una condizione logica (es. controllo di un processo, attesa di un segnale).

Per le PMI, un ciclo for può automatizzare report periodici, mentre un while può gestire un flusso di approvazione documentale finché lo stato non cambia.

Break, Continue e Else nei loop

Break, Continue e Else nei loop

Oltre ai loop di base (for e while), Python offre comandi di controllo che permettono di gestire il flusso in modo granulare. Comprenderli è essenziale per scrivere codice efficiente e leggibile.

Break interrompe completamente un ciclo. Utile quando una condizione specifica annulla l'elaborazione. Esempio: cerchi un elemento in una lista e, trovato, fermi la ricerca.

numeri = [10, 20, 30, 40, 50]
for n in numeri:
    if n == 30:
        print("Trovato!")
        break
    print(f"Controllo {n}")

Continue salta l'iterazione corrente e passa alla successiva. È ideale per filtrare dati. Nell'esempio, saltiamo i numeri dispari.

for n in range(10):
    if n % 2 != 0:
        continue
    print(f"{n} è pari")

Else nei loop: una funzionalità poco nota ma potente. Il blocco else di un for o while viene eseguito solo se il loop si completa senza interrompersi con break. È perfetto per verificare se una condizione non si è mai verificata, come una ricerca fallita.

lista = [1, 2, 3, 4, 5]
elemento_cercato = 10
for elemento in lista:
    if elemento == elemento_cercato:
        print("Trovato!")
        break
else:
    print(f"Elemento {elemento_cercato} non presente nella lista.")

Usa break per controlli precisi, continue per filtraggi, e else per gestire il caso "non trovato" senza variabili di stato superflue.

Funzioni e Modularità

```html

Funzioni e Modularità: Costruire Codice Riusabile

Una delle prime lezioni di Python che i principianti apprendono, ma che separa il codice disordinato da quello professionale, riguarda le funzioni. In Python, una funzione è un blocco di codice riutilizzabile, progettato per eseguire un'azione specifica. Comprendere come definirle, chiamarle e passare dati tra di esse è il fondamento per scrivere programmi puliti, leggibili e facili da manutenere. Questa sezione ti guiderà attraverso i concetti essenziali per padroneggiare le funzioni e la modularità, evitando errori comuni che portano a script confusi e difficili da modificare.

Perché Usare le Funzioni?

Scrivere un intero programma in un unico blocco di codice funziona per script molto semplici, ma diventa rapidamente ingestibile. Immagina di dover calcolare il totale di uno sconto più volte in un programma di fatturazione. Copiare e incollare lo stesso codice ogni volta è inefficiente e introduce rischi: se devi correggere un errore, dovrai modificarlo in ogni posizione. Le funzioni risolvono questo problema.

• DRY (Don't Repeat Yourself): Invece di duplicare codice, definisci una volta sola una funzione e richiamala ovunque serve.
• Leggibilità: Un programma strutturato in funzioni leggibili come un libro con capitoli, piuttosto che un unico, lungo paragrafo.
• Manutenibilità: Correggi o migliori una logica in un solo punto, impattando automaticamente tutte le chiamate.
• Testabilità: Puoi verificare il corretto funzionamento di una piccola unità di codice in isolamento.

Come Definire e Chiamare una Funzione

La sintassi per creare una funzione in Python è semplice. Si usa la parola chiave def, seguita dal nome della funzione, una coppia di parentesi che eventualmente accettano parametri, e due punti.

def saluta(nome):
    """Mostra un messaggio di benvenuto personalizzato."""
    print(f"Ciao, {nome}! Benvenuto nel corso di Python.")

Per eseguire (o "chiamare") la funzione, basta usare il suo nome seguito dalle parentesi, inserendo l'argomento attuale (nel nostro caso, una stringa):

saluta("Mario")  # Output: Ciao, Mario! Benvenuto nel corso di Python.

Il commento tra tre virgolette """ è una docstring. È una buona pratica documentare cosa fa la funzione, quali parametri accetta e cosa restituisce.

Parametri e Valori di Ritorno

Le funzioni diventano potenti quando interagiscono con il resto del programma. Lo fanno attraverso i parametri (dati in ingresso) e i valori di ritorno (dati in uscita).

Un parametro è una variabile che riceve un valore quando la funzione viene chiamata. Puoi avere parametri posizionali, keyword o valori di default.

def calcola_totale(prezzo, iva=22):
    """Calcola il totale applicando una percentuale di IVA."""
    importo_iva = prezzo * (iva / 100)
    return prezzo + importo_iva

totale = calcola_totale(100)  # Usa IVA di default (22)
print(totale)  # Output: 122.0
totale_ridotto = calcola_totale(iva=10, prezzo=100)  # Usa 10% di IVA
print(totale_ridotto)  # Output: 110.0

La parola chiave return termina l'esecuzione della funzione e invia un valore indietro al chiamante. Se ometti return, la funzione restituirà implicitamente None.

Errori Comuni da Evitare

Quando inizi a usare le funzioni, è facile incappare in questi errori:

• Funzioni troppo lunghe: Una funzione dovrebbe fare una sola cosa. Se supera le 20-30 righe, considera di spezzarla in sottofunzioni.
• Parametri non necessari: Non passare più dati di quelli che la funzione effettivamente utilizza.
• Effetti collaterali inattesi: Una funzione non dovrebbe (in genere) modificare variabili globali o strutture dati esterne senza una chiara documentazione. Questo rende il comportamento del programma imprevedibile.
• Assenza di Docstring: Senza una documentazione chiara, tu e altri sviluppatori faticherete a capire cosa fa una funzione dopo qualche mese.

Pratica Guidata: Una Funzione per un Calcolo

Proviamo a costruire una funzione che risolva un problema comune: calcolare l'area di un rettangolo e verificare se il risultato è valido. Questo esempio mostra come organizzare il codice in modo modulare.

def calcola_area_rettangolo(base, altezza):
    """
    Calcola l'area di un rettangolo.
    Restituisce l'area se i parametri sono positivi, altrimenti None.
    """
    if base <= 0 or altezza <= 0:
        print("Errore: base e altezza devono essere valori positivi.")
        return None
    area = base * altezza
    return area

# Esempio di utilizzo nel main del programma
base = 5
altezza = 10
area = calcola_area_rettangolo(base, altezza)

if area is not None:
    print(f"L'area del rettangolo è: {area}")
else:
    print("Impossibile calcolare l'area con i valori forniti.")

Questo codice è modulare: la logica di calcolo e validazione è isolata in una funzione. Il programma principale si occupa solo di chiamare la funzione e gestire il risultato.

Come Possiamo Aiutarti a Implementare Queste Competenze

Capire la teoria è il primo passo, ma l'applicazione pratica in contesti lavorativi richiede una guida esperta. Culture Digitali ti supporta per tradurre questi concetti in soluzioni concrete.

• Formazione aziendale personalizzata: Corsi di Python per dipendenti che mirano a risolvere problemi specifici della tua azienda (automazione report, pulizia dati, script di utilità).
• Consulenza tecnica: Aiutiamo le PMI e le PA a progettare architetture di codice modulare per i loro progetti, definendo funzioni chiave e standard di sviluppo.
• Sviluppo di tool interni: Realizziamo piccoli script o applicazioni modulari su misura per automatizzare processi ricorrenti, partendo da una solida struttura di funzioni.

CTA: Se vuoi creare un percorso di apprendimento concreto o sviluppare uno strumento interno, prenota una call gratuita con un nostro consulente per valutare le tue esigenze.

FAQ: Funzioni e Modularità

Posso chiamare una funzione prima di averla definita nel file?
No, in Python l'interpretazione del codice avviene dall'alto verso il basso. La definizione di una funzione deve apparire prima di ogni sua chiamata.

È meglio usare molti parametri o variabili globali dentro una funzione?
È quasi sempre meglio usare i parametri. Rende la funzione indipendente e il suo comportamento chiaro. L'uso di variabili globali (salvo casi specifici) crea dipendenze nascoste e complica il debug.

Quando devo usare una funzione e quando un ciclo?
Una funzione esegue un'azione specifica. Un ciclo (come for) ripete un'azione più volte. Spesso usi una funzione *all'interno* di un ciclo per operare su ogni elemento di una sequenza.

```

Definire funzioni con def e return

Definire funzioni con def e return

Per creare una funzione in Python si usa la parola chiave def, seguita dal nome della funzione, dai parametri tra parentesi e dal segno :. Tutto il codice che costituisce la funzione va indentato sotto questa riga.

La struttura di base è questa:

def nome_funzione(parametro1, parametro2):
    # Codice da eseguire
    risultato = parametro1 + parametro2
    return risultato

Il blocco return è fondamentale: determina il valore che la funzione restituisce quando viene chiamata. Senza return, la funzione esegue le operazioni ma restituisce None di default.

def saluta(nome):
    messaggio = f"Ciao, {nome}!"
    return messaggio

print(saluta("Mario"))  # Output: Ciao, Mario!

Una funzione può restituire più valori sotto forma di tupla, separati da virgole. Questo è utile per organizzare risultati complessi.

def calcola_area_perimetro(lato):
    area = lato ** 2
    perimetro = lato * 4
    return area, perimetro

Parametri posizionali, keyword e valori di default

Parametri posizionali, keyword e valori di default

Capire come passare i dati alle funzioni è fondamentale quando si impara come programmare in Python. I parametri definiscono l'interfaccia del tuo codice e ne determinano flessibilità e robustezza. Python offre tre modalità principali per dichiarare e utilizzare i parametri.

1. Parametri posizionali

Sono il modo più semplice e diffuso. I valori vengono associati ai parametri in base all'ordine in cui vengono passati.

def saluta(nome, messaggio):
    print(f"{messaggio}, {nome}!")

saluta("Mario", "Buongiorno")  # Output: Buongiorno, Mario!

Se sbagli l'ordine, il risultato sarà errato o genererà un errore. Usa i parametri posizionali per funzioni brevi con pochi argomenti e nomi ovvi.

2. Parametri keyword (named arguments)

Per migliorare leggibilità e manutenibilità, puoi specificare il nome del parametro quando chiami la funzione. L'ordine non conta più.

saluta(messaggio="Ciao", nome="Anna")  # Output: Ciao, Anna!

Questo approccio rende il codice più auto-documentato e riduce il rischio di errori, specialmente in team o in progetti complessi.

3. Valori di default (default arguments)

Puoi assegnare un valore predefinito a un parametro. Se non viene passato durante la chiamata, viene usato quello. I parametri con valore di default vanno sempre alla fine della dichiarazione.

def notifica(utente, azione="ha effettuato il login"):
    print(f"{utente} {azione}")

notifica("Luca")                    # Output: Luca ha effettuato il login
notifica("Sara", azione="ha completato l'ordine")  # Output: Sara ha completato l'ordine

I valori di default rendono le funzioni più flessibili e riducono la necessità di overload (non presente in Python come in altri linguaggi). Sono ideali per argomenti opzionali o che assumono un valore comune.

Mixando queste tecniche puoi creare API chiare e facili da usare, un passo crucile quando ti avvicini a librerie per l'automazione o lo sviluppo web.

Scope delle variabili (Global vs Local) e Closure

Scope delle variabili (Global vs Local) e Closure

Capire come Python gestisce la visibilità delle variabili è fondamentale per scrivere codice pulito e prevenire errori. In Python, lo scope (ambito) definisce dove una variabile è accessibile. Esistono principalmente due tipi: locale e globale, con un concetto avanzato come le closure.

Variabili Locali

Una variabile definita all'interno di una funzione ha uno scope locale: è visibile e utilizzabile solo all'interno di quella funzione. Non può essere letta o modificata dall'esterno. Questo aiuta a mantenere le funzioni indipendenti e a evitare conflitti di nomi tra variabili diverse.

Variabili Globali

Una variabile definita al di fuori di qualsiasi funzione, nel corpo principale del modulo, è globale. È accessibile da qualsiasi punto del codice, all'interno e all'esterno delle funzioni. Per modificarla all'interno di una funzione, è necessario usare la parola chiave global, altrimenti Python crea una nuova variabile locale con lo stesso nome.

Closure e Scoping Avanzato

Le closure sono un meccanismo potente in Python. Si verificano quando una funzione interna "ricorda" e accede alle variabili della funzione esterna in cui è definita, anche dopo che la funzione esterna ha terminato l'esecuzione. In pratica, la funzione interna chiude su lo scope della funzione esterna, conservando l'accesso ai suoi dati. Questo è utile per creare funzioni dinamiche, decoratori e fabbriche di funzioni senza l'uso di classi complesse.

Best Practice e Rischi Comuni

L'uso eccessivo di variabili globali può rendere il codice difficile da testare e mantenere (effetti collaterali). Le closure offrono un'alternativa più sicura per condividere stato in modo controllato. Un errore comune è dimenticare di dichiarare global quando si cerca di modificare una variabile globale all'interno di una funzione, portando a un errore di assegnazione o a un comportamento inatteso.

Per approfondire queste strutture e applicarle in progetti reali, la formazione pratica è essenziale.

Come possiamo aiutarti

Se desideri apprendere Python in modo strutturato per applicazioni in ambito automazione, analisi dati o sviluppo interno, il nostro percorso Formazione Python per Aziende e PA è pensato per te. Copriamo dai fondamentali a concetti avanzati come lo scope, le closure e la programmazione orientata agli oggetti, con esempi pratici pertinenti al tuo settore.

Scopri i corsi di programmazione

Richiedi un colloquio con un nostro consulente per valutare come integrare queste competenze nella tua organizzazione.

Programmazione Orientata agli Oggetti (OOP)

Programmazione Orientata agli Oggetti (OOP)

La Programmazione Orientata agli Oggetti (OOP) è uno dei paradigmi più potenti e diffusi nell'ecosistema Python, fondamentale per scrivere codice modulare, riutilizzabile e facile da manutenere. Per un principiante, l'OOP può sembrare astratto, ma si riduce a concetti intuitivi che modellano il mondo reale: oggetti, classi, ereditarietà e polimorfismo. In questo capitolo, imparerai non solo la teoria, ma anche come applicare questi principi in scenari pratici, preparandoti a progetti più strutturati.

Immagina di dover gestire una libreria digitale: invece di usare liste separate per autori, titoli e prestiti, puoi creare un oggetto "Libro" che incapsula tutte le sue proprietà (titolo, autore, stato) e azioni (prestare, restituire). Questa organizzazione riduce gli errori e semplifica il codice. Nella programmazione Python, l'OOP non è obbligatorio—puoi scrivere script semplici senza classi—ma è essenziale per applicazioni complesse come siti web, app o strumenti di automazione. Vediamo i concetti chiave passo dopo passo.

Classi e Oggetti: Le Basi Fondamentali

Una classe è uno "stampino" che definisce la struttura e il comportamento degli oggetti. È come un piano per creare istanze specifiche. Un oggetto è un'istanza concreta di una classe, con valori reali per le sue proprietà.

Ecco un esempio basilare per gestire un semplice libro in Python:

```python
class Libro:
def __init__(self, titolo, autore):
self.titolo = titolo
self.autore = autore
self.disponibile = True

def prestare(self):
if self.disponibile:
self.disponibile = False
return f"Libro '{self.titolo}' prestato."
else:
return "Libro non disponibile."

def restituisci(self):
self.disponibile = True
return f"Libro '{self.titolo}' restituito."

# Creazione di un oggetto
mio_libro = Libro("Python Crash Course", "Eric Matthes")
print(mio_libro.prestare()) # Output: Libro 'Python Crash Course' prestato.
```

Qui, Libro è la classe, e mio_libro è un oggetto. Il metodo __init__ (inizializzatore) costruisce l'oggetto con attributi specifici. I metodi come prestare definiscono azioni. Per un principiante, inizia con classi semplici: definisci attributi (dati) e metodi (funzioni legate all'oggetto). Un errore comune è dimenticare self, che riferisce all'istanza corrente; senza di esso, Python non riconosce gli attributi.

class Utente:
    def __init__(self, nome, email):
        self.nome = nome
        self.email = email

    def mostra_info(self):
        return f"Utente: {self.nome}, Email: {self.email}"
    
    def aggiorna_email(self, nuova_email):
        self.email = nuova_email

try:
    risultato = 10 / 0
except ZeroDivisionError:
    print("Non puoi dividere per zero!")

try:
    f = open('dati.txt', 'r')
    contenuto = f.read()
except FileNotFoundError:
    print("File non trovato.")
else:
    print("Lettura completata.")
finally:
    f.close() # Assicura che il file venga chiuso sempre

class SaldoInsufficiente(Exception):
    pass

# Esempio d'uso
if saldo < prelievo:
    raise SaldoInsufficiente("Credito non sufficiente per l'operazione")

try:
    file = open('dati.txt', 'r')
    contenuto = file.read()
except FileNotFoundError:
    print("Errore: il file non è stato trovato.")
except Exception as e:
    print(f"Si è verificato un errore imprevisto: {e}")
finally:
    if 'file' in locals() and not file.closed:
        file.close()
    print("Risorse rilasciate correttamente.")

class FormatoNonValidoError(Exception):
    """Eccezione per file con formato errato."""
    pass

# Esempio di utilizzo
def carica_dati(percorso_file):
    if not percorso_file.endswith('.json'):
        raise FormatoNonValidoError("Il file deve essere in formato JSON")
    # ... resto della logica

with open('dati.txt', 'r', encoding='utf-8') as file:
    contenuto = file.read()
    print(contenuto)

# Scrive (crea o sovrascrive il file)
with open('report.txt', 'w', encoding='utf-8') as file:
    file.write('Nuovo report generato.\\n')

# Aggiunge in fondo al file (append)
with open('report.txt', 'a', encoding='utf-8') as file:
    file.write('Aggiornamento alle 15:00.\\n')

import csv

# Leggi un CSV e accedi ai dati per riga
with open('clienti.csv', 'r', encoding='utf-8') as file:
    lettore = csv.DictReader(file)
    for riga in lettore:
        print(f"Cliente: {riga['nome']} - Email: {riga['email']}")

# Scrivi un nuovo CSV
dati_da_scrivere = [
    {'nome': 'Mario Rossi', 'email': 'm.rossi@example.com'},
    {'nome': 'Anna Verdi', 'email': 'a.verdi@example.com'}
]
with open('nuovi_clienti.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.DictWriter(file, fieldnames=['nome', 'email'])
    writer.writeheader()
    writer.writerows(dati_da_scrivere)

import json

# Dizionario complesso
configurazione = {
    'database': 'db_esempio',
    'credenziali': {'user': 'admin', 'password': 'segreta123'},
    'timeout': 30
}

# Salva su file JSON (per riuso o configurazione)
with open('config.json', 'w', encoding='utf-8') as file:
    json.dump(configurazione, file, indent=4)

# Ricarica i dati dal file
with open('config.json', 'r', encoding='utf-8') as file:
    config_lettura = json.load(file)
    print(config_lettura['database'])

with open('documenti.txt', 'r', encoding='utf-8') as file:
    contenuto = file.read()
    print(contenuto)

with open('documenti.txt', 'r', encoding='utf-8') as file:
    for riga in file:
        print(riga.strip())  # .strip() rimuove gli spazi superflui e il carattere di fine riga

with open('report.txt', 'w', encoding='utf-8') as file:
    file.write('Questo è il primo paragrafo.\n')
    file.write('Questo è il secondo.\n')