Use Type Hints Effectively

def calculate_discount(price, rate, apply):
    if apply:
        return price * (1 - rate)
    return price

def calculate_discount(price: float, rate: float, apply: bool) -> float:
    if apply:
        return price * (1 - rate)
    return price

username: str = "alice"
age: int = 30
is_active: bool = True

names: list[str] = ["Alice", "Bob"]
scores: dict[str, int] = {"alice": 95, "bob": 87}
unique_ids: set[int] = {1, 2, 3}

from typing import Optional, Union

def find_user(user_id: int) -> Optional[dict]:
    """Returns user dict or None if not found."""
    user = database.query(user_id)
    return user if user else None

def parse_value(input: str) -> int | float | None:
    try:
        return int(input)
    except ValueError:
        try:
            return float(input)
        except ValueError:
            return None

def format_id(id: int | str) -> str:
    return str(id)

from typing import Literal

def set_log_level(level: Literal["DEBUG", "INFO", "WARNING", "ERROR"]):
    logger.setLevel(level)

set_log_level("INFO")  # OK
set_log_level("TRACE")  # Type checker error

from typing import TypeVar, Generic

T = TypeVar('T')

def first_element(items: list[T]) -> T | None:
    return items[0] if items else None

numbers = [1, 2, 3]
first_num: int | None = first_element(numbers)  # int inferred

strings = ["a", "b", "c"]
first_str: str | None = first_element(strings)  # str inferred

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

int_stack: Stack[int] = Stack()
int_stack.push(42)
value: int = int_stack.pop()

K = TypeVar('K')
V = TypeVar('V')

class Cache(Generic[K, V]):
    def __init__(self) -> None:
        self._data: dict[K, V] = {}

    def get(self, key: K) -> V | None:
        return self._data.get(key)

    def set(self, key: K, value: V) -> None:
        self._data[key] = value

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> str:
        ...

class Circle:
    def __init__(self, radius: float):
        self.radius = radius

    def draw(self) -> str:
        return f"Circle(r={self.radius})"

class Square:
    def __init__(self, side: float):
        self.side = side

    def draw(self) -> str:
        return f"Square(s={self.side})"

def render(shape: Drawable) -> None:
    print(shape.draw())

render(Circle(5.0))
render(Square(10.0))

from typing import runtime_checkable

@runtime_checkable
class Saveable(Protocol):
    def save(self) -> None:
        ...

def save_data(obj: Saveable) -> None:
    if isinstance(obj, Saveable):  # Runtime check
        obj.save()

from typing import TypedDict

class UserDict(TypedDict):
    id: int
    name: str
    email: str
    age: int

def create_user(user_data: UserDict) -> None:
    # Type checker knows the structure
    print(f"User: {user_data['name']}")
    # print(user_data['invalid'])  # Type checker error

user: UserDict = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30
}

class UserDictOptional(TypedDict, total=False):
    id: int
    name: str
    email: str
    age: int
    phone: str

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str
    age: int = 0  # Optional with default

from typing import Callable

def apply_operation(
    value: int,
    operation: Callable[[int], int]
) -> int:
    return operation(value)

def double(x: int) -> int:
    return x * 2

result = apply_operation(5, double)  # 10

def process_items(
    items: list[str],
    processor: Callable[[str, int], str]
) -> list[str]:
    return [processor(item, i) for i, item in enumerate(items)]

def add_index(item: str, index: int) -> str:
    return f"{index}: {item}"

from typing import Any

def register_callback(
    callback: Callable[..., None]
) -> None:
    callback()  # Can be called with any arguments

from typing import TypeAlias

UserId: TypeAlias = int
UserName: TypeAlias = str
UserData: TypeAlias = dict[str, int | str]

def get_user(user_id: UserId) -> UserData:
    return {
        "id": user_id,
        "name": "Alice",
        "age": 30
    }

from typing import Callable

Handler: TypeAlias = Callable[[str], None]
Middleware: TypeAlias = Callable[[Handler], Handler]

def create_middleware(handler: Handler) -> Middleware:
    def middleware(next_handler: Handler) -> Handler:
        def wrapper(request: str) -> None:
            print("Before")
            next_handler(request)
            print("After")
        return wrapper
    return middleware

pip install mypy

mypy your_script.py

mypy --strict your_script.py

[mypy]
python_version = 3.10
warn_return_any = True
warn_unused_configs = True
disallow_untyped_defs = True
disallow_any_generics = True
check_untyped_defs = True

def calculate_total(items: list[dict]) -> float:
    return sum(item['price'] * item['quantity'] for item in items)

def validate_email(email: str) -> bool:
    return '@' in email and '.' in email

from typing import Any

def process_legacy_data(data: Any) -> Any:
    # TODO: Add proper types later
    return transform(data)

result = complex_legacy_function()  # type: ignore

def example() -> None:
    value = [1, 2, 3]
    reveal_type(value)  # Revealed type is "builtins.list[builtins.int]"

from typing import assert_type

def get_number() -> int:
    return 42

value = get_number()
assert_type(value, int)  # Passes type check

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from complex_module import ComplexType

def process(data: 'ComplexType') -> None:  # String annotation avoids runtime import
    ...