[Python] IA, Match e case.

[Gabriele Battaglia]

Sera. Voglio condividere con voi una cosa che ho scoperto su Python ed 
il mio entusiasmo per alcune cose che questa IA fa davvero bene.


Chiacchierando con ChatGPT 4o, questa sera ho imparato qualcosa che non 
conoscevo sul mio linguaggio di programmazione preferito.

Ammetto che non leggo quasi mai i what's new di Python e so di sbagliare.


Ad ogni modo, non so cosa ne pensiate voi ma io trovo entusiasmante 
ChatGPT 4o, mi ha spalancato un mondo; probabilmente non sarà così per 
la maggior parte di quelli bravi, alle cui competenze è molto più 
difficile arrivare ma per me è una manna dal cielo.

Non è il primo che provo, seguo la IA da quando i non addetti ai lavori, 
come il sottoscritto, hanno iniziato a sentirne parlare, cos'era? 
Gennaio 2023? Ho provato ovviamente Gemini, GPT3.5 e compagnia, tuttavia 
mi pare che la 4o abbia fatto un bel salto.

Mi piacerebbe leggere qualche vostra riflessione, se ne avete voglia: 
intendo tenendosi stretti al rapporto fra IA e programmazione perchè con 
altre tematiche IA, finiremmo per non uscirne più.


Beh, intanto ditemi, vi piace questa spiegazione?


ChatGPT4o:

L'istruzione `match` e `case` è una nuova funzionalità introdotta in 
Python 3.10, che implementa il concetto di "pattern matching". È simile 
all'istruzione `switch`/`case` presente in altri linguaggi di 
programmazione come C, C++ e Java, ma è più potente e flessibile.
Pattern Matching con `match` e `case`
Il pattern matching consente di confrontare una variabile con una serie 
di modelli (patterns) e di eseguire il codice corrispondente al primo 
modello che corrisponde. Ecco come funziona:
Sintassi di Base
python
def example(value):
     match value:
         case 1:
             print("Value is 1")
         case 2:
             print("Value is 2")
         case 3:
             print("Value is 3")
         case _:
             print("Value is something else")
Spiegazione del Codice
1.
Dichiarazione `match`:
• La variabile `value` viene confrontata con una serie di modelli 
all'interno del blocco `match`.
2.
Dichiarazioni `case`:
• Ogni `case` rappresenta un modello a cui `value` potrebbe corrispondere.
• Se `value` corrisponde al modello specificato, viene eseguito il 
codice all'interno del blocco `case`.
3.
Modello `_`:
• Il modello `_` è un jolly che corrisponde a qualsiasi valore non 
gestito dagli altri `case`.
• È simile all'istruzione `default` in altri linguaggi di programmazione.
Esempi Avanzati
Il pattern matching in Python non si limita ai semplici confronti di 
valori. Può anche essere utilizzato per confrontare strutture dati 
complesse come tuple, liste e dizionari.
Confronto di Tuple
python
def example(value):
     match value:
         case (1, x):
             print(f"Tuple starts with 1, second element is {x}")
         case (2, y):
             print(f"Tuple starts with 2, second element is {y}")
         case _:
             print("Tuple does not match any pattern")
Confronto di Liste
python
def example(value):
     match value:
         case [1, x]:
             print(f"List starts with 1, second element is {x}")
         case [2, y]:
             print(f"List starts with 2, second element is {y}")
         case _:
             print("List does not match any pattern")
Confronto di Dizionari
python
def example(value):
     match value:
         case {"key1": x}:
             print(f"Dictionary contains key 'key1' with value {x}")
         case {"key2": y}:
             print(f"Dictionary contains key 'key2' with value {y}")
         case _:
             print("Dictionary does not match any pattern")
Esempio Applicato alla Tua Richiesta
Nel contesto del tuo progetto, puoi utilizzare `match` e `case` per 
filtrare le partite in base a diversi criteri:
python
def filter_games(games, criterion):
     filtered_games = []
     for game in games:
         match criterion["criterion"]:
             case "white_player":
                 if game.headers['White'] == criterion['value']:
                     filtered_games.append(game)
             case "black_player":
                 if game.headers['Black'] == criterion['value']:
                     filtered_games.append(game)
             case "result":
                 if game.headers['Result'] == criterion['value']:
                     filtered_games.append(game)
             case _:
                 raise ValueError("Unsupported criterion")
     return filtered_games
In questo esempio, il pattern matching viene utilizzato per determinare 
quale criterio utilizzare per filtrare le partite.
Conclusione
Il pattern matching con `match` e `case` in Python 3.10 è una 
funzionalità potente e flessibile che consente di scrivere codice più 
leggibile e conciso per confrontare valori e strutture dati complessi. 
Se stai utilizzando una versione di Python precedente alla 3.10, questa 
funzionalità non sarà disponibile, e dovrai utilizzare costrutti 
alternativi come catene di `if`/`elif`/`else`.
Se hai ulteriori domande o necessiti di ulteriori chiarimenti, fammi sapere!

Gabry: la richiesta era stata qualcosa del genere.

In python, usando la libreria chess, devo caricare un PGN con svariate 
migliaia di partite di scacchi. Mi aiuti a filtrarle in maniera che 
possa ricavarne un sottoinsieme da cui scegliere?


Questa è una parte della risposta. Altrove mi ha spiegato in maniera 
direi perfetta, come caricare il file, visualizzarlo eccetera.

Si sente che sono entusiasta?


Grazie per avermi letto.


-- 
Gabriele Battaglia (IZ4APU)
--... ...--  -.. .  .. --.. ....- .- .--. ..-  - ..-  . .
Sent from my Giant Desktop PC