प्रकार एनोटेशन की मूल बातें

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

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

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

# Annotation without assignment (declaration only)
future_value: int

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")

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)

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]:

from typing import Union

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

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

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))

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

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

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

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