Python Academy · Lezione

Nozioni di base su match e case

Diramare in base ai pattern dei valori

Nozioni di base su match e case è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Pattern matching strutturale

Python 3.10 ha introdotto il pattern matching strutturale con l'istruzione match. Confronta un valore con una serie di pattern ed esegue il primo che corrisponde, offrendo possibilità molto più ampie rispetto a una catena di if/elif.

Sintassi di base

Scriva match seguito dal soggetto, quindi uno o più blocchi case. Viene eseguito il primo caso corrispondente.

command = 'start'

match command:
    case 'start':
        print('Starting up')
    case 'stop':
        print('Shutting down')

# prints: Starting up

Corrispondenza con valori letterali

I pattern più semplici sono valori letterali: numeri, stringhe, True, False e None. Corrispondono quando il soggetto è uguale al valore letterale.

code = 404

match code:
    case 200:
        print('OK')
    case 404:
        print('Not Found')
    case 500:
        print('Server Error')

Il carattere jolly _

Il carattere di sottolineatura _ è un pattern jolly che corrisponde a qualsiasi valore. Lo inserisca per ultimo come caso predefinito generale, analogamente a else.

code = 418

match code:
    case 200:
        print('OK')
    case _:
        print('Unknown status')

Combinare con OR

Usi l'operatore | all'interno di un case per farlo corrispondere a uno qualsiasi di più pattern.

code = 301

match code:
    case 200 | 201 | 204:
        print('Success')
    case 301 | 302:
        print('Redirect')
    case _:
        print('Other')

Acquisire il valore

Un nome semplice in un pattern acquisisce il soggetto nella variabile corrispondente. Lo usi quando ha verificato un caso generale, ma desidera comunque conservare il valore.

value = 42

match value:
    case 0:
        print('zero')
    case other:
        print('got', other)

L'ordine è importante

I casi vengono verificati dall'alto verso il basso e vince la prima corrispondenza. Un pattern di acquisizione generale inserito troppo presto nasconderà i casi successivi e più specifici.

x = 5

match x:
    case n:           # matches everything first!
        print('caught by capture')
    case 5:
        print('this never runs')

Match non restituisce nulla

match è un'istruzione, non un'espressione, quindi non restituisce un valore. Assegni un valore a una variabile all'interno dei casi se ha bisogno di un risultato.

day = 6
label = ''

match day:
    case 0 | 6:
        label = 'weekend'
    case _:
        label = 'weekday'

print(label)

Corrispondenza con None

Può confrontare direttamente None. È più pulito rispetto a un controllo esplicito is None all'interno di una catena.

def describe(value):
    match value:
        case None:
            return 'nothing'
        case _:
            return 'something: ' + str(value)

print(describe(None))
print(describe(7))

Un dispatcher pratico

Il pattern matching è particolarmente efficace come dispatcher di comandi: trasforma una lunga catena di if in una tabella chiara di casi.

def handle(cmd):
    match cmd:
        case 'help':
            return 'Showing help'
        case 'quit' | 'exit':
            return 'Goodbye'
        case _:
            return 'Unknown command'

print(handle('exit'))
print(handle('foo'))

Corrispondenza con True, False e None

Le costanti True, False e None vengono confrontate per identità, non per uguaglianza. Questo le rende singleton affidabili su cui diramare l'esecuzione.

def report(flag):
    match flag:
        case True:
            return 'enabled'
        case False:
            return 'disabled'
        case None:
            return 'unset'

print(report(True))
print(report(None))

Verifica rapida

Che cosa fa il pattern jolly _ in un'istruzione match?

Riepilogo

Ha imparato a diramare l'esecuzione in base ai pattern dei valori.

match verifica i casi dall'alto verso il basso; vince la prima corrispondenza.
Confronti valori letterali, usi _ come caso generale e combini i pattern con |.
Un nome semplice acquisisce il valore.
match è un'istruzione, non un'espressione.

Domande Frequenti

La lezione «Nozioni di base su match e case» è gratuita?

Sì — il testo completo di «Nozioni di base su match e case» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Nozioni di base su match e case»?

Diramare in base ai pattern dei valori Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Nozioni di base su match e case»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy