Python Academy · Lezione

Confrontare sequenze e mapping

Destrutturare liste e dizionari

Confrontare sequenze e mapping è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 2 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 con destrutturazione

La vera potenza di match è la destrutturazione. I pattern di sequenza e di mapping consentono di verificare la struttura dei dati ed estrarne contemporaneamente i valori.

Corrispondenza con una lista di lunghezza fissa

Un pattern di sequenza tra parentesi quadre corrisponde a una lista o a una tupla di quella lunghezza esatta, associando ogni elemento a un nome.

point = [3, 4]

match point:
    case [x, y]:
        print('x =', x, 'y =', y)

La lunghezza deve corrispondere

Un pattern con due elementi non corrisponde a una sequenza di tre elementi. Ogni caso verifica sia la struttura sia la lunghezza.

data = [1, 2, 3]

match data:
    case [a, b]:
        print('pair')
    case [a, b, c]:
        print('triple:', a, b, c)

Combinare valori letterali e acquisizioni

Può fissare alcune posizioni a valori letterali e acquisire le altre. In questo modo corrisponderanno solo le sequenze che iniziano con il valore letterale indicato.

command = ['move', 10, 20]

match command:
    case ['move', dx, dy]:
        print('moving by', dx, dy)
    case ['stop']:
        print('stopping')

Acquisire il resto con *

Un nome preceduto da un asterisco acquisisce tutti gli elementi rimanenti come lista, in modo simile allo spacchettamento esteso.

items = [1, 2, 3, 4, 5]

match items:
    case [first, *rest]:
        print('first:', first)
        print('rest:', rest)

Pattern vuoti e singoli

I pattern di sequenza gestiscono con chiarezza i casi limite: una lista vuota, un singolo elemento o molti elementi.

def describe(seq):
    match seq:
        case []:
            return 'empty'
        case [x]:
            return 'one: ' + str(x)
        case [x, *rest]:
            return 'many, first ' + str(x)

print(describe([]))
print(describe([9]))
print(describe([1, 2, 3]))

Corrispondenza con i dizionari

Un pattern di mapping usa le parentesi graffe. Verifica che le chiavi indicate siano presenti e associa i relativi valori. Nel soggetto possono essere presenti anche chiavi aggiuntive.

event = {'type': 'click', 'x': 10, 'y': 20}

match event:
    case {'type': 'click', 'x': x, 'y': y}:
        print('click at', x, y)

Corrispondenza parziale delle chiavi

Un pattern di mapping richiede solo le chiavi elencate. Le altre chiavi vengono ignorate, una caratteristica utile per i messaggi con campi facoltativi.

event = {'type': 'key', 'code': 'A', 'extra': 1}

match event:
    case {'type': 'key', 'code': code}:
        print('key pressed:', code)

Acquisire le chiavi rimanenti

Usi **rest per acquisire tutte le coppie chiave-valore non corrispondenti in un dizionario.

event = {'type': 'move', 'dx': 5, 'dy': 7}

match event:
    case {'type': 'move', **rest}:
        print('move details:', rest)

Annidare i pattern

I pattern possono essere annidati liberamente. Può far corrispondere un dizionario che contiene una lista, destrutturando entrambi contemporaneamente.

data = {'name': 'grid', 'size': [3, 4]}

match data:
    case {'name': name, 'size': [w, h]}:
        print(name, 'is', w, 'by', h)

Qui le stringhe non sono sequenze

I pattern di sequenza deliberatamente non corrispondono a stringhe o byte, anche se sono iterabili. In questo modo si impedisce che una stringa venga destrutturata accidentalmente carattere per carattere.

value = 'hi'

match value:
    case [a, b]:
        print('matched as sequence')
    case str():
        print('matched as string')

Verifica rapida

Che cosa associano first e rest quando il pattern [first, *rest] viene confrontato con [1, 2, 3, 4]?

Riepilogo

Ha imparato a destrutturare liste e dizionari.

I pattern di sequenza verificano la lunghezza e associano gli elementi.
*rest acquisisce gli elementi rimanenti della lista.
I pattern di mapping fanno corrispondere le chiavi; le chiavi aggiuntive sono consentite.
**rest acquisisce le coppie rimanenti del dizionario; i pattern possono essere annidati.

Domande Frequenti

La lezione «Confrontare sequenze e mapping» è gratuita?

Sì — il testo completo di «Confrontare sequenze e mapping» è 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 «Confrontare sequenze e mapping»?

Destrutturare liste e dizionari 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 2 di 4.

Quanto tempo richiede la lezione «Confrontare sequenze e mapping»?

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