Python's generics system brings type safety to dynamic code, enabling reusable functions and classes that work across types while aiding static analysis tools like mypy. Introduced in Python 3.5 through PEP 483 and refined in versions like 3.12, generics use type variables without runtime overhead, leveraging duck typing for flexibility.<\/p>\n
Generics parameterize types, allowing structures like lists or custom classes to specify element types at usage time. Core building block: Create flexible utilities by annotating parameters and returns with type variables. A practical example is a universal adder for any comparable types.<\/p>\n Mypy infers and enforces matching types\u2014 This works seamlessly across any type.<\/p>\n Inherit from Sample Usage:<\/strong><\/p>\n Save the Stack class to Test errors: Add Fix by matching types. Correct usage passes silently.<\/p>\n Generics catch errors early in IDEs and CI pipelines. Run Python’s generics system brings type safety to dynamic code, enabling reusable functions and classes that work across types while aiding static analysis tools like mypy. Introduced in Python 3.5 through PEP 483 and refined in versions like 3.12, generics use type variables without runtime overhead, leveraging duck typing for flexibility. What Are Generics? Generics parameterize […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[88],"tags":[],"_links":{"self":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/2029"}],"collection":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2029"}],"version-history":[{"count":2,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/2029\/revisions"}],"predecessor-version":[{"id":2039,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/2029\/revisions\/2039"}],"wp:attachment":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2029"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2029"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2029"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}TypeVar<\/code> from typing<\/code> (built-in since 3.12). They exist purely for static checking\u2014no enforcement at runtime, unlike Java's generics.<\/p>\nfrom typing import TypeVar\nT = TypeVar('T') # Placeholder for any type<\/code><\/pre>\nGeneric Functions in Action<\/h2>\n
from typing import TypeVar\n\nT = TypeVar('T') # Any type supporting +\n\ndef add(a: T, b: T) -> T:\n return a + b\n\n# Usage\nresult1: int = add(5, 3) # Returns 8, type int\nresult2: str = add("hello", "world") # Returns "helloworld", type str\nresult3: float = add(2.5, 1.7) # Returns 4.2, type float<\/code><\/pre>\nadd(1, "a")<\/code> fails checking. Another example: identity function.<\/p>\ndef identity(value: T) -> T:\n return value<\/code><\/pre>\nBuilding Generic Classes<\/h2>\n
Generic[T]<\/code> for type-aware containers (or use class Stack[T]:<\/code> in 3.12+). A real-world Result<\/code> type handles success\/error cases like Rust's Result<T, E><\/code>.<\/p>\nfrom typing import Generic, TypeVar\n\nT = TypeVar('T') # Success type\nE = TypeVar('E') # Error type\n\nclass Result(Generic[T, E]):\n def __init__(self, value: T | None = None, error: E | None = None):\n self.value = value\n self.error = error\n self.is_ok = error is None\n\n def unwrap(self) -> T | None:\n if self.is_ok:\n return self.value\n raise ValueError(f"Error: {self.error}")<\/code><\/pre>\nclass Stack(Generic[T]):\n def __init__(self) -> None:\n self.items: list[T] = []\n\n def push(self, item: T) -> None:\n self.items.append(item)\n\n def pop(self) -> T:\n return self.items.pop()<\/code><\/pre>\n# Result usage\ndef divide(a: float, b: float) -> Result[float, str]:\n if b == 0:\n return Result(error="Division by zero")\n return Result(value=a \/ b)\n\nsuccess = divide(10, 2)\nprint(success.unwrap()) # 5.0\n\nfailure = divide(10, 0)\n# failure.unwrap() #raises ValueError\n\n# Stack usage\nint_stack: Stack[int] = Stack()\nint_stack.push(1)\nint_stack.push(42)\nprint(int_stack.pop()) # 42\n\nstr_stack: Stack[str] = Stack()\nstr_stack.push("hello")\nprint(str_stack.pop()) # "hello"<\/code><\/pre>\nAdvanced Features<\/h2>\n
\n
K = TypeVar('K'); V = TypeVar('V')<\/code> for dict-like classes: class Mapping(Generic[K, V]):<\/code>.<\/li>\nT = TypeVar('T', bound=str)<\/code> restricts to subclasses of str<\/code>.<\/li>\nTypeVar('T', contravariant=True)<\/code> for input-only types.<\/li>\n<\/ul>\nMypy in Practice<\/h2>\n
stack.py<\/code>. Run mypy stack.py<\/code>\u2014no errors for valid code.<\/p>\nstack: Stack[int] = Stack[str]()<\/code> then mypy stack.py<\/code>:<\/p>\nstack.py: error: Incompatible types in assignment (expression has type "Stack[str]", variable has type "Stack[int]") [assignment]<\/code><\/pre>\nPractical Benefits and Tools<\/h2>\n
mypy script.py<\/code> to validate. No performance hit\u2014type hints erase at runtime. Ideal for libraries like FastAPI or Pydantic.<\/p>\n","protected":false},"excerpt":{"rendered":"