Python's type system has evolved significantly since the introduction of type hints in Python 3.5. Today, we'll explore advanced typing concepts that help create more robust and maintainable code. From generic programming with TypeVars to runtime type checking with Pydantic, we'll cover the tools and techniques that modern Python developers should know.
TypeVars are the foundation of generic programming in Python, allowing you to create functions and classes that work with multiple types while maintaining type safety. The bound parameter is particularly powerful for ensuring type constraints.
from typing import TypeVar, Generic, List
# Basic TypeVar
T = TypeVar('T')
# Bounded TypeVar - can only be Model or its subclasses
class Model:
def save(self) -> None: pass
ModelT = TypeVar('ModelT', bound=Model)
# TypeVar with constraints - can only be str or bytes
StrOrBytes = TypeVar('StrOrBytes', str, bytes)
class Repository(Generic[ModelT]):
def __init__(self) -> None:
self.items: List[ModelT] = []
def save_item(self, item: ModelT) -> None:
# Type checker knows item has save() method
item.save()
self.items.append(item)
def get_all(self) -> List[ModelT]:
return self.items
# Example usage with inheritance
class User(Model):
def save(self) -> None:
print("Saving user...")
class Post(Model):
def save(self) -> None:
print("Saving post...")
# These are valid
user_repo = Repository[User]()
post_repo = Repository[Post]()
# This would be a type error - int is not bound to Model
# int_repo = Repository[int]()TypedDict brings type safety to dictionaries by allowing you to specify the types of dictionary keys and values. It's particularly powerful when working with **kwargs and API responses.
from typing import TypedDict, Optional, Any
# Base configuration type
class BaseConfig(TypedDict):
debug: bool
timeout: int
# Extended configuration with optional fields
class AdvancedConfig(BaseConfig, total=False):
retry_count: int
cache_ttl: int
def configure_app(**kwargs: Any) -> None:
# Without TypedDict, kwargs is untyped
pass
def configure_app_typed(**kwargs: BaseConfig) -> None:
# Type checker ensures kwargs has correct structure
debug: bool = kwargs['debug']
timeout: int = kwargs['timeout']
# Using with function kwargs
def create_user(
**kwargs: TypedDict('UserCreate', {
'name': str,
'email': str,
'age': Optional[int]
})
) -> None:
# Type checker knows the structure of kwargs
name: str = kwargs['name']
email: str = kwargs['email']
age: Optional[int] = kwargs.get('age')
# Usage examples
configure_app_typed(debug=True, timeout=30) # OK
configure_app_typed(debug=True) # Error: missing timeout
create_user(name="John", email="john@example.com") # OK
create_user(name="John") # Error: missing emailProtocols enable structural subtyping (duck typing) with static type checking. They define interfaces that classes can implement without explicit inheritance.
from typing import Protocol, runtime_checkable
@runtime_checkable
class Drawable(Protocol):
def draw(self) -> None: ...
class Circle:
def draw(self) -> None:
print("Drawing a circle")
class Square:
def draw(self) -> None:
print("Drawing a square")
def render(shape: Drawable) -> None:
shape.draw()
# Both work because they implement the Drawable protocol
render(Circle()) # OK
render(Square()) # OKType guards help narrow down union types in a type-safe way. They're particularly useful when working with data that could be of multiple types.
from typing import Union, TypeGuard
def is_string_list(value: list[Union[str, int]]) -> TypeGuard[list[str]]:
return all(isinstance(x, str) for x in value)
def process_strings(items: list[Union[str, int]]) -> None:
if is_string_list(items):
# Type checker knows items is list[str] here
print(", ".join(items)) # OK
else:
# Handle mixed or int list
print("List contains non-string values")Pydantic bridges the gap between static type checking and runtime type validation. It uses Python's type annotations to provide data validation and serialization.
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, Field, EmailStr
class User(BaseModel):
id: int
username: str = Field(..., min_length=3)
email: EmailStr
created_at: datetime = Field(default_factory=datetime.now)
profile: Optional['Profile'] = None
class Profile(BaseModel):
bio: Optional[str] = None
age: int = Field(ge=0, lt=150)
interests: list[str] = Field(default_factory=list)
# Runtime validation
try:
user = User(
id="not_an_integer", # Will raise validation error
username="jo", # Too short
email="invalid_email" # Invalid email format
)
except ValueError as e:
print(f"Validation error: {e}")While both Pydantic and traditional type hints aim to improve code quality, they serve different purposes:
Pydantic offers many advanced features for complex data validation and transformation scenarios.
from pydantic import BaseModel, Field, validator
from typing import Annotated
class AdvancedUser(BaseModel):
# Custom type with validation
age: Annotated[int, Field(gt=0, lt=150)]
# Complex validation with custom error messages
password: Annotated[str, Field(
min_length=8,
description="User password",
examples=["very_secure_pwd123"]
)]
# Custom validators
@validator('password')
def validate_password(cls, v: str) -> str:
if not any(c.isupper() for c in v):
raise ValueError('Password must contain uppercase letter')
if not any(c.isdigit() for c in v):
raise ValueError('Password must contain a digit')
return v
# Config for model behavior
class Config:
anystr_strip_whitespace = True
validate_assignment = True
extra = 'forbid'Advanced type annotations in Python provide powerful tools for creating type-safe and maintainable code. By combining static type checking with runtime validation through tools like Pydantic, you can catch errors early and create more robust applications. Understanding these concepts is crucial for modern Python development, especially in larger projects where type safety becomes increasingly important.
Using type annotations in your Python projects offers several key advantages:
While adding type annotations requires some initial investment, the long-term benefits in code quality, maintainability, and developer productivity make them an essential tool in modern Python development. Whether you're working on a small script or a large enterprise application, incorporating type hints can significantly improve your development workflow and code reliability.