Istruzione switch case in Python: guida per principianti

Esplora l'istruzione match-case di Python, introdotta in Python 3.10, e scopri come il pattern matching strutturale porta un nuovo livello di eleganza e potenza nella programmazione in Python. Vedremo la sua sintassi, le applicazioni in data science e machine learning e anche come si confronta con gli switch-case tradizionali in altri linguaggi. Se sei alle prime armi con Python, dai un'occhiata al nostro Python Cheat Sheet per principianti. 

Capire gli switch case tradizionali

Prima di Python 3.10, gli sviluppatori Python dovevano usare molte istruzioni if-elif-else o dizionari per simulare la funzionalità di uno switch case. Ecco un esempio di base usando if-elif-else:

day = "Saturday"

if day == "Saturday" or day == "Sunday":
    print(f"{day} is a weekend.")
elif day in ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]:
    print(f"{day} is a weekday.")
else:
    print("That's not a valid day of the week.")

# Saturday is a weekend.

Introduzione a match e case in Python 3.10

Con l'introduzione di match-case, Python offre ora una funzionalità basata sul pattern matching strutturale, che permette di scrivere logiche condizionali più pulite e potenti.

Che cos'è il pattern matching strutturale?

Il pattern matching strutturale, introdotto nella PEP 634, è un modo per confrontare e destrutturare strutture dati in base alla loro forma e ai loro contenuti. È più flessibile del semplice confronto di valori e consente di lavorare con sequenze, mapping e persino istanze di classi personalizzate.

Sintassi di base di match-case

Ecco un semplice esempio di match-case in azione. Categorizziamo i giorni della settimana in weekend o feriali:

day = "Monday"

# Match the day to predefined patterns
match day:
    case "Saturday" | "Sunday":
        print(f"{day} is a weekend.")  # Match weekends
    case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
        print(f"{day} is a weekday.")  # Match weekdays
    case _:
        print("That's not a valid day of the week.")  # Default case

# Monday is a weekday.

Concetti chiave nell'esempio:

1. Pattern matching con case:

   • case "Saturday" | "Sunday": corrisponde a uno qualsiasi dei pattern elencati. Il simbolo | funge da operatore OR.

   • case _: un caso jolly (predefinito) per gestire input non validi.

2. Nessun break necessario: a differenza dello switch-case tradizionale, Python esce dal blocco match dopo la prima corrispondenza riuscita.

Confronto tra match-case e if-elif-else

Nella tabella seguente puoi vedere come si confrontano le due tecniche: 

Casi d'uso avanzati di match e case in Python

Applicazioni in data science

L'istruzione match-case di Python può essere molto utile nei compiti di preprocessing in data science. Il preprocessing spesso comporta la categorizzazione dei dati in gruppi diversi in base a criteri specifici.

Per esempio, in un dataset di animali, potresti volerli categorizzare in base alla classe, come mammiferi, uccelli, rettili, ecc. Ecco un esempio semplificato:

animal = "Eagle"
match animal:
    case "Eagle" | "Parrot":
        print("Bird")
    case "Lion" | "Tiger":
        print("Mammal")
    case "Python" | "Crocodile":
        print("Reptile")
    case _:
        print("Unknown Class")

# Bird

Questo approccio semplifica la logica if-else complessa e rende il codice più leggibile e manutenibile, soprattutto quando si lavora con grandi dataset con più categorie.

Sviluppo web

In framework web come Django o Flask, puoi usare match-case per instradare le richieste HTTP o gestire codici di errore specifici. Scopri di più su Python per sviluppatori con il nostro corso online. 

Esempio: instradare i metodi HTTP

# Example: Handling HTTP methods in a Flask-like application
method = "POST"

match method:
    case "GET":
        print("Fetching resource...")
    case "POST":
        print("Creating resource...")
    case "PUT":
        print("Updating resource...")
    case "DELETE":
        print("Deleting resource...")
    case _:
        print("Unsupported HTTP method.")

# Creating resource...

Spiegazione:

• La variabile method rappresenta il tipo di richiesta HTTP.
• Ogni case corrisponde a un possibile metodo HTTP, semplificando ciò che altrimenti richiederebbe più istruzioni if-elif.

Gestione delle API

Quando elabori risposte API, match-case può essere usato per gestire i diversi status code o categorizzare le risposte JSON.

Esempio: gestione degli status code

# Example: API response status code handling
status_code = 200

match status_code:
    case 200:
        print("Request succeeded.")
    case 404:
        print("Resource not found.")
    case 500:
        print("Server error. Please try again later.")
    case _:
        print("Unknown status code.")

# Request succeeded.

Questo approccio rende più semplice interpretare e rispondere agli esiti delle API.

Pattern matching semplice vs complesso

Il match-case di Python non è limitato alla corrispondenza di valori costanti; può gestire pattern più articolati. Ecco la distinzione:

Corrispondenza di costanti semplice

Corrispondenze semplici come stringhe o interi sono ottime per una logica pulita e leggibile, come mostrato negli esempi sopra.

Pattern matching complesso

Quando lavori con dati strutturati (ad es., dizionari, sequenze), match-case può estrarre e manipolare i dati in modo efficiente.

Esempio: corrispondenza di strutture dati

# Example: Categorizing configurations
config = {"type": "database", "name": "PostgreSQL", "version": 13}

match config:
    case {"type": "database", "name": name, "version": version}:
        print(f"Database: {name} (Version {version})")
    case {"type": "cache", "name": name}:
        print(f"Cache system: {name}")
    case _:
        print("Unknown configuration.")

# Database: PostgreSQL (Version 13)

Spiegazione:

• Il primo case estrae name e version dal dizionario, rendendo più semplice lavorare con dati strutturati.

• Questo dimostra la vera potenza del pattern matching strutturale di Python, molto oltre ciò che le implementazioni switch-case tradizionali possono ottenere.

Ecco la sezione ridotta con solo le aggiunte rilevanti:

Oltre lo switch-case di base

Oltre alla semplice corrispondenza di valori, il match-case di Python include alcune funzionalità che lo distinguono dagli switch-case tradizionali in altri linguaggi.

Clausole di guardia

Una guardia è una condizione if associata a un case che deve essere vera affinché il case corrisponda. Questo ti permette di combinare il pattern matching con logica aggiuntiva — qualcosa che gli switch tradizionali non possono fare:

match point:
    case (x, y) if x == y:
        print(f"Point is on the diagonal at {x}")
    case (x, y) if x > 0 and y > 0:
        print(f"Point {point} is in the first quadrant")
    case (x, y):
        print(f"Point {point} is somewhere else")

# Point (3, 7) is in the first quadrant

Le guardie sono utili quando il solo pattern non è abbastanza specifico per distinguere tra i casi.

Oltre lo switch-case: pattern di destrutturazione

Sebbene gli esempi sopra si concentrino su un uso in stile switch-case, è utile sapere che il match-case di Python può anche destrutturare sequenze, dizionari e istanze di classi — catturando valori al loro interno come parte del match. Questo va ben oltre ciò che offrono gli switch in altri linguaggi ed è uno dei motivi principali per cui il pattern matching strutturale è stato aggiunto a Python.

Per esempio, fare il match di un'istanza di classe:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

point = Point(0, 5)

match point:
    case Point(x=0, y=0):
        print("Origin")
    case Point(x=0, y=y):
        print(f"On the Y-axis at {y}")
    case Point():
        print("Somewhere else on the plane")

# On the Y-axis at 5

Se vuoi approfondire questi pattern più avanzati, dai un'occhiata alla PEP 636, il tutorial ufficiale sul pattern matching strutturale.

Errori comuni e buone pratiche con lo switch case in Python

Suggerimenti per il debug

Un errore comune quando si usa match-case in Python è dimenticare di includere l'underscore (_) per il caso predefinito, analogo all'"else" nelle istruzioni if-else tradizionali. Questo può portare a comportamenti imprevisti se nessuno dei casi specifici corrisponde. Includi sempre un caso predefinito per gestire valori inattesi o vari.

Considerazioni sulle prestazioni

Sebbene l'istruzione match-case sia uno strumento potente, il suo impatto sulle prestazioni del codice Python, in particolare nelle applicazioni su larga scala, va considerato. In scenari con un gran numero di casi o con pattern matching complesso, le prestazioni possono potenzialmente risentirne. Profilare e testare il codice in scenari reali è fondamentale per capire e mitigare eventuali criticità di performance.

Match-case in Python rispetto allo switch-case tradizionale

Analisi comparativa

Il match-case di Python differisce in modo significativo dagli switch-case tradizionali presenti in linguaggi come Java o C++. In Java, per esempio, lo switch è limitato alla corrispondenza di soli valori scalari (come interi e tipi enum), mentre il match-case di Python offre una capacità di pattern matching molto più flessibile, permettendo la corrispondenza di tipi di dati complessi, come sequenze e istanze di classe. Questo rende l'implementazione di Python più potente, ma richiede anche una comprensione più profonda dei concetti di pattern matching.

Guida alla transizione

Per i programmatori abituati agli switch-case tradizionali in linguaggi come C++ o Java, passare al match-case di Python richiede un cambio di prospettiva: dalla semplice corrispondenza di valori al pattern matching.

È importante capire che il match-case di Python è più di un semplice switch-case; è uno strumento versatile per destrutturare tipi di dati ed estrarre informazioni da strutture complesse. Fare pratica con diversi tipi di dati e pattern è la chiave per padroneggiarlo.

Conclusione

Le istruzioni match e case di Python, introdotte nella versione 3.10, sono ormai una funzionalità consolidata del Python moderno. Da allora, il pattern matching strutturale è maturato fino a diventare uno strumento affidabile disponibile in ogni versione attivamente supportata del linguaggio — inclusa l'ultima release stabile, Python 3.14.4 (aprile 2026), oltre alle 3.13 e 3.12.

Puoi leggere di più sulle funzioni in Python nel nostro tutorial completo ed esplorare questo e altri concetti nel nostro corso Intermediate Python.