Introduces a type variable that can be substituted with concrete types when using generics.

Declare a reusable type placeholder for generic programming in Python.

When writing generic functions, classes, or protocols that need to operate over multiple types while preserving type information.

Used in Python's typing module, typically at module level before defining generic constructs.

T = TypeVar('T')

Identifier assignment to a TypeVar call with a string literal matching the identifier.

T can be any valid identifier; the string literal should usually match the identifier for clarity.

• List
• Dict
• Generic
• Protocol
• TypeVar
• Mapping
• Sequence

• T can be replaced with any other valid type variable name like U
• V
• T_co
• T_contra.

Using a different string literal than the variable name (e.g., T = TypeVar('U')) which can confuse readers; forgetting to import TypeVar from typing.

Similar to using TypeVar with bounds or variance; contrasted with concrete types like int or str, and with ParamSpec (for callable parameters).

Confusing TypeVar with concrete types or mixing up covariant/contravariant flags can lead to type checker errors.

• typing generics
• type variables
• generic programming

The string literal in TypeVar is primarily for runtime introspection and debugging; it does not affect type checking but should match the variable name by convention.

Signals to type checkers and readers that the annotated entities are generic over a type.

Think of 'T' as a placeholder for any type, like a blank to fill in later.

Commonly placed at the top of a module alongside other typing imports.

Consider using ParamSpec for callable generics or TypeVarTuple for variadic generics.