Il linguaggio a undici anni dalla 3.0
Il 14 ottobre 2019 la Python Software Foundation ha rilasciato Python 3.8, sotto la regia di Łukasz Langa come Release Manager. A undici anni dal rilascio di Python 3.0 (dicembre 2008), la linea è matura, stabile, con un ecosistema di librerie sconfinato. La 3.8 consolida diverse direttrici aperte da release precedenti, con l’aggiunta di novità sintattiche ponderate.
La 3.8 è una Regular Release con supporto fino a ottobre 2024 (cinque anni) secondo il ciclo di supporto standard. La transizione da Python 2 — formalmente terminato il 1° gennaio 2020 — è ormai completata nella maggior parte dei progetti produttivi.
Walrus Operator (PEP 572)
La novità sintattica più discussa è il walrus operator :=, descritto da PEP 572. Consente di assegnare e valutare in un’unica espressione:
# Prima
line = file.readline()
while line:
process(line)
line = file.readline()
# Con walrus
while line := file.readline():
process(line)Oppure in filtri e comprehension:
filtered = [y for x in data if (y := compute(x)) > threshold]La discussione pubblica su PEP 572 è stata accesa — Guido van Rossum (BDFL storico) si è espresso favorevolmente e ha persino dichiarato che l’intensità del dibattito lo ha portato a decidere di ritirarsi dalla guida del linguaggio (annuncio luglio 2018, passaggio a governance di Steering Council). La 3.8 è la prima release post-BDFL e prima a includere formalmente il nuovo operatore.
Positional-only parameters (PEP 570)
PEP 570 introduce la sintassi / per marcare parametri esclusivamente posizionali:
def greet(name, /, greeting="Hello"):
return f"{greeting}, {name}!"
greet("Anna") # OK
greet("Anna", greeting="Hi") # OK
greet(name="Anna") # TypeError: name is positional-onlyQuesta costruzione allinea Python alle funzioni built-in (es. len(obj, /)) e permette refactor sicuri: rinominare un parametro non è breaking change se è posizionale.
F-string self-documenting
Piccola ma gradita: f"{x=}" produce x=valore, utile per debugging:
x = 42
y = [1, 2, 3]
print(f"{x=}, {y=}") # x=42, y=[1, 2, 3]Typing evoluto
Il modulo typing guadagna costrutti significativi:
TypedDict (PEP 589)
Tipizza dict con schema noto:
from typing import TypedDict
class User(TypedDict):
name: str
age: int
active: bool
u: User = {"name": "Anna", "age": 30, "active": True}Final (PEP 591)
Marker per variabili/metodi non sovrascrivibili:
from typing import Final
MAX_RETRIES: Final = 5Literal (PEP 586)
Tipi che accettano solo valori specifici:
from typing import Literal
def log(level: Literal["debug", "info", "error"]) -> None: ...Protocol (PEP 544)
Structural subtyping — “duck typing” formalizzato:
from typing import Protocol
class Drawable(Protocol):
def draw(self) -> None: ...
def render(obj: Drawable) -> None:
obj.draw()Il typing Python, iniziato con PEP 484 nel 2015, raggiunge con la 3.8 una maturità che abilita type checker come mypy, pyright (Microsoft), pyre (Facebook), pyre-check a lavorare su codebase enterprise complesse.
Performance
La 3.8 include ottimizzazioni diffuse:
- Shared cache per metadati dei moduli — import più veloci
- Optimized LOAD_GLOBAL opcode
- asyncio run() e Task improvements
- pickle Protocol 5 (PEP 574) — out-of-band buffers, zero-copy per grandi dati
Altri contributi
- multiprocessing.shared_memory (PEP 574 correlato) — memoria condivisa cross-process senza serialization
- reversed() per dict — iterazione in ordine inverso
- Math costants —
math.prod(),math.isqrt(),math.perm(),math.comb() - sys.platform per Android
- f-string ’=’ specification
Breaking changes
La 3.8 non introduce rotture massicce ma:
- Python 2 è deprecato completamente — EOL 1° gennaio 2020
- Alcuni moduli deprecati da 3.3/3.4 sono rimossi
- DeprecationWarning visibili di default in
__main__
Impatto sull’ecosistema
Le principali librerie si aggiornano per sfruttare le novità:
- Django — supporto walrus e positional-only nei metodi interni
- FastAPI (in crescita dal 2018) — integrazione profonda con typing TypedDict/Protocol
- Pydantic — field validation con Literal
- SQLAlchemy 2.x (in sviluppo) — uso estensivo di TypedDict e Protocol
- pytest, Flask, Celery — aggiornamenti progressivi
Nel contesto italiano
Python 3.8 entra nei progetti italiani con il ritmo usuale:
- Data science — team di analytics adottano rapidamente (pandas, NumPy, Jupyter pronto)
- Web — Django e FastAPI in produzione
- ML/AI — TensorFlow, PyTorch compatibili
- PA — nuovi progetti in Python adottano 3.8; progetti esistenti 3.6/3.7 migrano progressivamente
Riferimenti: Python 3.8.0 (14 ottobre 2019). Łukasz Langa come Release Manager. PEP 572 (walrus), PEP 570 (positional-only), PEP 589 (TypedDict), PEP 591 (Final), PEP 586 (Literal), PEP 544 (Protocol), PEP 574 (pickle 5). Python Steering Council (post-BDFL, 2018). Python Software Foundation.