Type annotations in Python are a way to add explicit type information to variables, function parameters, and return values using a syntax introduced in PEP 484. They are used to improve code readability, enable better IDE support, and allow static type checking with tools like mypy, Pyright, or PyCharm.

Syntax and Basic Usage

• Function parameters and return types:

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

  Here, name: str indicates the expected input type, and -> str specifies the return type.

• Variable annotations:

  count: int = 0
  names: list[str] = ["Alice", "Bob"]

Key Features

• No runtime enforcement: Type annotations are ignored by the Python interpreter. They do not raise errors if incorrect types are used at runtime.

• Static analysis: Tools like mypy use annotations to catch type-related bugs before execution.

• Improved developer experience: IDEs use type hints for auto-completion, refactoring, and error detection.

Advanced Type Annotations

• Union types: Use | (Python 3.10+) or Union (earlier versions):

  def process(data: int | str) -> bool:
      return isinstance(data, int)

• Optional types: Use X | None or Optional[X]:

  def get_user(id: int) -> str | None:
      # returns None if user not found
      pass

• Generics and TypeVar:

  from typing import TypeVar, Generic
  T = TypeVar('T')
  
  class Box(Generic[T]):
      def __init__(self, item: T):
          self.item = item

• Typed dictionaries:

  from typing import TypedDict
  
  class Person(TypedDict):
      name: str
      age: int

Benefits

• Better code documentation

• Fewer runtime errors via static analysis

• Improved collaboration and code maintainability

• Enhanced tooling support (e.g., AI-assisted code completion)

For more details, refer to the official typing documentation and PEP 484.