`Declarația type și Generics Moderne în Python 3.12+ (PEP 695)` în Python

Variabile și tipuri de date Python 3.12+

Ghid complet pentru noua sintaxă de tipare introdusă în Python 3.12 (PEP 695): instrucțiunea type, parametri generici clari fără TypeVar și evaluare leneșă a tipurilor recursive.

Sintaxă

type Punct[T] = tuple[T, T]; type Arbore[T] = T | list[Arbore[T]];

Până la apariția versiunii Python 3.12, definirea tipurilor generice și a alias-urilor de tip era greoaie, necesitând importuri din modulul typing (cum ar fi TypeVar, Generic și TypeAlias). Standardul PEP 695 a revoluționat sistemul de tipare din Python prin introducerea cuvântului cheie nativ type și a unei sintaxe compacte cu paranteze drepte pentru parametri generici, identică cu cea din limbaje moderne precum TypeScript, Rust sau Swift.

Sintaxa veche (Python < 3.12) vs. Noua instrucțiune type (Python 3.12+)

# METODA VECHE:
from typing import TypeVar, Union, TypeAlias
T = TypeVar('T')
CoordonateVechi: TypeAlias = tuple[T, T] # Necesita declarare separata de TypeVar

# NOU ÎN PYTHON 3.12+: DECLARAȚIA type NATIVĂ
type Coordonate[T] = tuple[T, T]

# Putem folosi alias-ul direct:
pct_int: Coordonate[int] = (10, 20)
pct_float: Coordonate[float] = (3.14, 2.71)

# Alias simplu pentru structuri complexe:
type DateUtilizator = dict[str, list[int | str]]

Clase și Funcții Generice Simplificate

Nu mai este nevoie să moșteniți clasa Generic[T]. Parametrii de tip sunt adăugați direct după numele funcției sau al clasei:

Clasă generică scrisă în Python 3.12+

# Clasa declară parametrul generic [T] direct în antet:
class Stiva[T]:
    def __init__(self) -> None:
        self._elemente: list[T] = []

    def adauga(self, element: T) -> None:
        self._elemente.append(element)

    def extrage(self) -> T:
        return self._elemente.pop()

# Funcție generică cu constrângere de tip (Type Bound):
def dubleaza[T: (int, float, str)](valoare: T) -> T:
    return valoare * 2

Evaluarea Leneșă (Lazy Evaluation) și Tipuri Recursive

Un mare beneficiu al instrucțiunii type este faptul că expresia de tip este evaluată în mod leneș (lazy) la runtime. Acest lucru permite crearea nativă de tipuri recursive (cum ar fi arbori sau structuri JSON) fără a apela la șiruri de caractere (forward references):

# Tip recursiv curat:
type StructuraJson = dict[str, StructuraJson] | list[StructuraJson] | str | int | float | bool | None

type ArboreBinar[T] = tuple[T, ArboreBinar[T] | None, ArboreBinar[T] | None]