Python Academy · Lezione

Annotazioni di tipo di base

Annoti variabili, parametri delle funzioni e tipi restituiti.

Annotazioni di tipo di base è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Cosa sono le annotazioni di tipo?

Le annotazioni di tipo sono suggerimenti che dichiarano il tipo previsto di variabili, parametri e valori restituiti. Non vengono applicate a runtime, ma vengono lette da type checker come mypy.

def greet(name: str) -> str:
    return f"Hello, {name}"

result: str = greet("Alice")
print(result)

Annotazioni delle variabili

Annoti le variabili a livello di modulo, di classe o locali con i due punti seguiti dal tipo.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Annotazioni dei parametri delle funzioni

Annoti ogni parametro nella firma della funzione. Utilizzi -> type per annotare il tipo restituito.

def add(a: int, b: int) -> int:
    return a + b

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Tipi di raccolta integrati (Python 3.9+)

A partire da Python 3.9, utilizzi direttamente i tipi integrati in minuscolo come generici: list[int], dict[str, int], tuple[int, ...].

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

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

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

Optional e Union

X | None (Python 3.10+) o Optional[X] indica che un valore può essere X o None. X | Y indica che può essere X o Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Tipi Union

int | str (Python 3.10+) o Union[int, str] annota un valore che può essere di uno tra diversi tipi.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Alias di tipo

Assegni un'espressione di tipo a un nome per creare un alias riutilizzabile, migliorando la leggibilità.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Annotazioni Callable

Utilizzi Callable[[arg_types], return_type] per annotare le funzioni passate come argomenti.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

Annotare *args e **kwargs

Annoti *args con il tipo degli elementi, non con una tupla, e **kwargs con il tipo dei valori.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from future import annotations

Aggiunga questa importazione all'inizio del file per abilitare la valutazione posticipata delle annotazioni, consentendo i riferimenti in avanti senza virgolette.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

Guardia TYPE_CHECKING

Importi i tipi solo durante il controllo dei tipi, non a runtime, per evitare importazioni circolari o importazioni pesanti.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Verifica rapida

Quale sintassi di annotazione indica che una funzione non restituisce nulla?

Riepilogo

Annoti le variabili con name: Type, i parametri con param: Type e i valori restituiti con -> Type. Utilizzi list[T], dict[K,V] (Python 3.9+), X | None (3.10+) e from __future__ import annotations per i riferimenti in avanti.

Domande Frequenti

La lezione «Annotazioni di tipo di base» è gratuita?

Sì — il testo completo di «Annotazioni di tipo di base» è 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 «Annotazioni di tipo di base»?

Annoti variabili, parametri delle funzioni e tipi restituiti. 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 1 di 4.

Quanto tempo richiede la lezione «Annotazioni di tipo di base»?

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