Il pattern matching con le funzioni in Python

Il pattern matching in python ti consente di confrontare una variabile con una serie di pattern e di eseguire un blocco di codice basato sul primo pattern che corrisponde. 

Si basa sull'istruzione match e sulle clausole case.

1. match variabile:
2.      case pattern1:
3.          # Esegui qualcosa
4.      case pattern2:
5.          # Esegui qualcosa di diverso
6.     case _:
7.          # Il carattere underscore (_) è un "wildcard" che corrisponde a qualsiasi cosa

E' una funzionalità introdotta nella versione 3.10 del linguaggio.

Rende il codice più leggibile, specialmente quando si tratta di dati complessi, e più facile mantenere e modificare.

Per chi proviene da altri linguaggi di programmazione, il pattern matching in Python può sembrare un po' diverso, ma è una funzionalità utile che conviene apprendere. Ti permette di sviluppare lo script seguendo il paradigma della programmazione funzionale.

Ecco qualche esempio pratico.

Questa funzione abbina dei semplici valori in entrata a delle stringhe in uscita.

1. def descrivi_numero(numero):
2.     match numero:
3.         case 1:
4.             return "Uno"
5.        case 2:
6.             return "Due"
7.        case _:
8.             return "Altro numero"

Quando chiami la funzione passandogli 1, la funzione esegue il primo case, perché il valore di case 1 corrisponde all'argomento (1).

Quindi, restituisce "uno" come valore di ritorno.

print(descrivi_numero(1))

Uno

Se invece chiami la funzione con l'argomento 3, la funzione non trova nessuna corrispondenza con case 1 e case 2.

In questo caso l'istruzione match esegue case _ e stampa "Altro numero"

Questo accade perché il simbolo "_" è un jolly e corrisponde a qualsiasi carattere.

print(descrivi_numero(3))

Altro numero

Il pattern matching con le liste e le tuple

Il pattern matching diventa davvero potente quando lo utilizzi con strutture di dati complesse come liste o tuple.

Ad esempio, questo script riceve come argomento una lista.

1. def analizza_lista(lista):
2.    match lista:
3.        case []:
4.             return "Lista vuota"
5.        case [primo_elemento]:
6.             return f"Lista con un elemento: {primo_elemento}"
7.        case [primo, *resto]:
8.             return f"Lista con più elementi, il primo è: {primo}"

Quando chiami la funzione con una lista con due o più elementi, l'istruzione match esegue il terzo case.

print(analizza_lista([1, 2, 3]))

Lista con più elementi, il primo è: 1

Ecco un altro esempio simile al precedente:

1. def analizza_dati(data):
2.     match data:
3.         case (a, b, c):
4.             print(f"Tre elementi: {a}, {b}, {c}")
5.         case [a, b, *resto]:
6.             print(f"Lista con almeno due elementi: {a}, {b}, resto: {resto}")
7.         case _:
8.             print("Pattern non riconosciuto")

Ora chiama la funzione passandogli una lista con tre elementi. La funzione esegue il primo case.

analizza_dati((1, 2, 3))      

Tre elementi: 1, 2, 3

Se invece chiami la funzione con una lista di cinque elementi, la funzione esegue il secondo case.

analizza_dati([1, 2, 3, 4, 5]) 

Lista con almeno due elementi: 1, 2, resto: [3, 4, 5]

Il pattern matching con le liste

Infine, puoi utilizzare il pattern matching anche  con oggetti.

1. class Auto:
2.     def __init__(self, marca, modello):
3.         self.marca = marca
4.         self.modello = modello
5. def descrivi_auto(auto):
6.       match auto:
7.             case Auto(marca="Fiat", modello=modello):
8.                  return f"Auto Fiat, modello {modello}"
9.             case Auto(marca=marca, modello=_):
10.                  return f"Auto di marca {marca}"
11.             case _:
12.                  return "Non è un'auto"
13. auto = Auto("Fiat", "500")
14. print(descrivi_auto(auto))

Questo script chiama la funzione passandogli un oggetto come argomento.

La funzione riceve l'oggetto, lo elabora e restituisce il seguente output

Auto Fiat, modello 500

Il pattern matching ti permette di rendere lo script molto più leggibile.