Python 3.10: pattern matching strutturale ed error message migliorati

Ricerca & Sviluppo

Quantum Computing, Blockchain, IoT & Industria 4.0, Robotica, Energia & Sostenibilità. Prototipi e proof-of-concept per validare le tecnologie emergenti.

Scopri le aree di ricerca →

Ottobre 2021

Python 3.10 è stato rilasciato il 4 ottobre 2021, con Pablo Galindo Salgado come Release Manager. La release introduce cambiamenti strutturali al parser (nuovo parser PEG, PEP 617, che era arrivato in 3.9) e novità sintattiche di peso, inclusa quella più discussa della serie 3.x: il pattern matching.

Structural Pattern Matching (PEP 634-636)

La novità più visibile: match / case. Tre PEP coordinati (634 specifica, 635 motivazione, 636 tutorial). Sintatticamente ispirato a OCaml/Haskell/Scala/Rust, con adattamenti Python:

def describe(point):
    match point:
        case (0, 0):
            return "origine"
        case (x, 0):
            return f"sull'asse X (x={x})"
        case (0, y):
            return f"sull'asse Y (y={y})"
        case (x, y):
            return f"punto ({x}, {y})"
        case _:
            return "non riconosciuto"

Match non è un switch/case C-like — è un pattern matching destrutturante che supporta:

• Literal patterns — case 42, case "done", case True
• Capture patterns — case x vincola
• Sequence patterns — case [a, b, *rest]
• Mapping patterns — case {"name": name, "age": age}
• Class patterns — case Point(x=0, y=y) — usa __match_args__
• OR patterns — case 1 | 2 | 3
• Guard patterns — case x if x > 0
• Wildcard — case _

Il meccanismo si integra con protocolli esistenti (es. __match_args__ su dataclass) rendendo naturale il matching su strutture complesse.

Type Union syntax (PEP 604)

Un’altra sintassi elegante: X | Y sostituisce Union[X, Y] negli annotazioni di tipo.

# Prima (ancora supportato)
from typing import Union
def f(x: Union[int, str]) -> Union[int, None]: ...

# Python 3.10+
def f(x: int | str) -> int | None: ...

La sintassi rispecchia l’uso di | in altre lingue tipizzate (TypeScript, Kotlin) e rende le annotations più leggibili.

Parenthesized context managers

Il nuovo parser PEG (PEP 617) abilita una sintassi multi-line per with:

with (
    open("input.txt") as fin,
    open("output.txt", "w") as fout,
    lock_resource() as resource,
):
    # body
    ...

Prima, formattare multi-manager era scomodo — servivano contextlib.ExitStack o backslash continuations. Ora è sintatticamente pulito.

Error messages migliorati

Il nuovo parser PEG permette error message molto più precisi:

# Python 3.9
File "foo.py", line 1
    x = {'a': 1, 'b': 2, 'c': 3
                              ^
SyntaxError: invalid syntax

# Python 3.10
File "foo.py", line 1
    x = {'a': 1, 'b': 2, 'c': 3
         ^
SyntaxError: '{' was never closed

Gli errori indicano la causa e non solo il punto dove il parser si è bloccato. Anche i messaggi di NameError suggeriscono “did you mean…?” per variabili con typo.

Altri contributi typing

• TypeAlias explicit (PEP 613): Vector: TypeAlias = list[float]
• ParamSpec (PEP 612): tipizzazione di decorators che preservano signature
• TypeGuard (PEP 647): narrowing di tipo esplicito per runtime check
• Concatenate (PEP 612)

zip(strict=True)

zip() accetta strict=True per sollevare ValueError se gli iterabili hanno lunghezze diverse — utile per debugging di dati inattesi.

Altre novità

• Distutils deprecato (rimozione in 3.12)
• async with contextlib.aclosing() (PEP 637)
• int.bit_count() — popcount
• dict union operators (consolidati da 3.9): d1 | d2

Supporto e adozione

Python 3.10 ha supporto fino a ottobre 2026 (standard 5 anni). L’adozione nei progetti è relativamente rapida:

• Black, mypy, ruff aggiungono supporto
• Django 4.0 (dicembre 2021) supporta 3.10
• FastAPI, Pydantic — pieno supporto pattern matching negli esempi e docs

Performance

Le ottimizzazioni del core:

• Inline dei constant literals
• Optimized store/load
• struct pack/unpack migliorati

Benchmark medi: 3-10% più veloce di 3.9 per workload tipici.

Nel contesto italiano

Python 3.10 si diffonde normalmente:

• Data science — adozione rapida
• Backend web — nuovi progetti su 3.10 dal 2022
• PA — politica di adozione più lenta; 3.8/3.9 restano dominanti per un po’

Il structural pattern matching è accolto con interesse — simile a match in Rust/Scala, cambia lo stile di codice Python verso forme più funzionali per parsing e state machine.

Riferimenti: Python 3.10.0 (4 ottobre 2021). Pablo Galindo Salgado come Release Manager. PEP 634/635/636 (pattern matching), PEP 604 (union syntax), PEP 617 (PEG parser), PEP 613 (TypeAlias), PEP 612 (ParamSpec, Concatenate), PEP 647 (TypeGuard).