typing avanzato

perché typing

typing non rende python statico, ma aiuta IDE, refactor e onboarding. riduce bug nei contratti tra funzioni.

type hints base

def area(r: float) -> float:
    return 3.1415 * r ** 2

name: str = "buzatu"

collezioni e optional

from typing import Optional

users: list[str] = ["samir", "studio"]
lookup: dict[str, int] = {"a": 1}

cache: Optional[int] = None

usa Optional quando il valore può essere assente.

dataclass e typed dict

from dataclasses import dataclass
from typing import TypedDict

@dataclass
class Shot:
    id: str
    frames: int

class Payload(TypedDict):
    ok: bool
    value: str

dataclass rende i modelli chiari e serializzabili.

protocols

i protocol definiscono contratti strutturali senza ereditarietà esplicita.

from typing import Protocol

class Renderer(Protocol):
    def render(self, frame: int) -> None:
        ...

tooling

• mypy o pyright per static check.
• ruff per linting veloce.
• editor con autocomplete tipizzato.

checklist finale

• usa type hints per tutte le funzioni pubbliche.
• definisci dataclass per i modelli principali.
• documenta optional e default chiaramente.
• integra type checking nel CI.

panoramica

In questo capitolo su typing avanzato, type hints, dataclass e protocolli per rendere il codice stabile. L'obiettivo è trasformare i concetti in micro-pattern riutilizzabili con esempi piccoli e verificabili.

Lavora in sequenza: leggi, prova, modifica gli snippet e annota i trade-off principali (performance, leggibilità, manutenzione).

obiettivi

• capire e applicare perché typing in uno scenario reale
• capire e applicare type hints base in uno scenario reale
• capire e applicare collezioni e optional in uno scenario reale
• capire e applicare dataclass e typed dict in uno scenario reale

scheda rapida

def main():
    dati = [1, 2, 3]
    risultati = [x * 2 for x in dati]
    print(risultati)

if __name__ == "__main__":
    main()

Adatta questo scheletro agli esempi della lezione e sostituisci i dati con il tuo dominio.

tips

• usa un venv per ogni progetto
• separa logica e I/O
• mantieni funzioni piccole e nominative
• usa Optional esplicito
• preferisci list[str] (py3.9+)
• definisci TypedDict per dict strutturati

mini progetto

Aggiungi type hints a un modulo di utilità.

• definisci tipi per input/output
• aggiungi TypedDict per payload
• usa Literal per valori fissi
• verifica con un checker

output atteso: uno script o query ripetibile con risultati verificabili.