Python Academy · Lezione

Tipi complessi: List, Dict, Optional, Union

Utilizzi correttamente i generics del modulo typing e Optional/Union.

Lezione 2 di 413 passaggi

Tipi complessi: List, Dict, Optional, Union è 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.

Panoramica del modulo typing

Prima di Python 3.9, i tipi generici come List, Dict e Tuple provenivano da typing. Dalla versione 3.9 è possibile utilizzare direttamente i tipi integrati.

from typing import List, Dict, Tuple, Optional, Union

# Python 3.9+: use list[int], dict[str,int] directly
# Python 3.8-: use typing.List[int], typing.Dict[str,int]

List e Sequence

Utilizzi list[T] per le sequenze modificabili e Sequence[T] quando accetta qualsiasi sequenza ordinata (lista, tupla, stringa).

from typing import Sequence

def total(nums: list[int]) -> int:
    return sum(nums)

def first(items: Sequence[str]) -> str:
    return items[0]   # works with list, tuple, str

Dict e Mapping

Utilizzi dict[K,V] per i dizionari modificabili e Mapping[K,V] per gli oggetti simili a dizionari in sola lettura.

from typing import Mapping

def lookup(data: Mapping[str, int], key: str) -> int | None:
    return data.get(key)

result = lookup({"a": 1, "b": 2}, "a")
print(result)   # 1

Annotazioni delle tuple

Lunghezza fissa: tuple[int, str, float]. Lunghezza variabile: tuple[int, ...].

def point() -> tuple[float, float]:
    return (1.0, 2.0)

def first_n(n: int) -> tuple[int, ...]:
    return tuple(range(n))

# Named tuple with types:
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Optional[T]

Optional[T] è una forma abbreviata di T | None. È sempre la scelta corretta quando un parametro può essere assente.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:
    db: dict[int, dict[str, str]] = {
        1: {"name": "Alice"}
    }
    return db.get(user_id)

Tipi Union

Union[X, Y] o X | Y (3.10+) per i valori che possono essere di uno tra diversi tipi.

from typing import Union

def stringify(value: Union[int, float, str]) -> str:
    return str(value)

# Python 3.10+:
def stringify2(value: int | float | str) -> str:
    return str(value)

Tipi Literal

Literal["a","b","c"] limita un valore a uno specifico insieme di valori letterali.

from typing import Literal

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> None:
    with open(path, mode):
        pass

open_file("data.txt", "read")    # ok
# open_file("data.txt", "exec")  # mypy error

TypedDict

TypedDict annota la struttura dei dizionari in cui ogni chiave è associata a un tipo specifico.

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int
    email: str | None

def greet(user: User) -> str:
    return f"Hello, {user['name']}"

alice: User = {"name": "Alice", "age": 30, "email": None}

Set e FrozenSet

Annoti gli insiemi con set[T] e gli insiemi immutabili con frozenset[T].

def unique(items: list[int]) -> set[int]:
    return set(items)

def allowed_methods() -> frozenset[str]:
    return frozenset({"GET", "POST", "DELETE"})

Iterable e Iterator

Utilizzi Iterable[T] per qualsiasi oggetto su cui è possibile eseguire un ciclo; Iterator[T] per gli oggetti con __next__.

from typing import Iterable, Iterator

def evens(numbers: Iterable[int]) -> Iterator[int]:
    return (n for n in numbers if n % 2 == 0)

for n in evens([1, 2, 3, 4, 5]):
    print(n)   # 2 4

Any e NoReturn

Any esclude un valore dal controllo dei tipi. NoReturn indica funzioni che non restituiscono mai un valore, perché sollevano sempre un'eccezione o entrano in un ciclo infinito.

from typing import Any, NoReturn

def accept_all(x: Any) -> None:
    print(x)

def crash(msg: str) -> NoReturn:
    raise RuntimeError(msg)   # never returns normally

Verifica rapida

Cosa significa Optional[str]?

Rispondi nella lezione interattiva

Riepilogo

Utilizzi list[T], dict[K,V] e tuple[T,...] per le raccolte. Optional[T] = T | None. Union[X,Y] o X|Y per più tipi. Literal per valori specifici; TypedDict per strutture di dizionari tipizzate; Any per escludere un valore dal controllo dei tipi.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 76
Lezioni: 320

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Tipi complessi: List, Dict, Optional, Union» è gratuita?

Sì — il testo completo di «Tipi complessi: List, Dict, Optional, Union» è 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 «Tipi complessi: List, Dict, Optional, Union»?

Utilizzi correttamente i generics del modulo typing e Optional/Union. 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 «Tipi complessi: List, Dict, Optional, Union»?

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

Annotazioni di tipo di base
Tipi complessi: List, Dict, Optional, Union
TypeVar, classi generiche e Protocol
Esecuzione di mypy e correzione degli errori di tipo

← Torna a Python Academy