Decorators: The Foundation
A Python decorator is syntactic sugar for wrapping one function with another to modify its behavior. The @ syntax is just a convenient way to apply this wrapping at function definition time. The key insight is that Python functions are first-class objects — they can be passed as arguments, returned from other functions, and stored in variables. A decorator is simply a function that takes a function as input and returns a new function as output. A useful decorator adds behavior before and/or after the wrapped function executes or decides whether to call it at all. The functools.wraps decorator preserves the wrapped function’s metadata (name, docstring, type hints) through the decoration, which is important for debugging and documentation.
Decorator Factories: Decorators That Take Arguments
Plain decorators cannot accept arguments — they just take a function and return a function. Decorator factories solve this by adding one more level of nesting: a function that takes configuration arguments and returns a decorator. A retry decorator factory illustrates this well. You want to write @retry(max_attempts=3, delay=1.0) on a function to make it automatically retry on failure. The retry function takes max_attempts and delay as arguments and returns a decorator. The decorator wraps the target function in a retry loop. The three-level nesting of factory, decorator, and wrapper is the standard pattern for parameterized decorators.
Stateful Decorators
Sometimes a decorator needs to maintain state across calls — counting how many times a function has been called, caching its results, or tracking execution time across multiple invocations. Closures naturally capture state in the outer scope: a counter variable in the decorator closure is shared across all calls to the wrapped function. For more complex state a decorator can be implemented as a class with a __call__ method. Each time the decorator is applied a new instance is created with its own state. Python’s standard library includes functools.lru_cache, a stateful decorator that implements memoization by maintaining a dictionary of argument-to-result mappings.
Metaclasses: Classes of Classes
In Python everything is an object including classes. A class is an instance of its metaclass. The default metaclass for user-defined classes is type. A metaclass is a class whose instances are classes. By defining a custom metaclass you control how classes are created. The classic metaclass use case is registering subclasses automatically. A plugin system where all concrete plugin implementations are automatically registered when they are defined uses a metaclass that adds each new subclass to a registry dictionary. Python 3.6 introduced __init_subclass__ as a simpler alternative for many metaclass use cases. It is called on a class whenever it is subclassed and is perfect for automatic registration, enforcing interface contracts, and configuring subclasses based on class-level attributes.
Descriptors: The Power Behind Python’s Property System
Descriptors are objects that define how attribute access works. Python’s property, classmethod, and staticmethod built-ins are all implemented as descriptors. A custom descriptor implements __get__, __set__, and __delete__ methods. The __get__ method is called when the attribute is accessed, __set__ when it is assigned, and __delete__ when it is deleted. Descriptors enable elegant patterns like validation attributes that check values before assignment, computed attributes that calculate values on access, and lazy attributes that compute expensive values on first access and cache them. For new Python code in 2026 prefer __init_subclass__ over metaclasses for subclass registration and configuration, and use metaclasses only when you need to intercept the full class creation process.
