Python Decorators: Definition, Purpose, and Implementation
Python decorators are a powerful tool that allows developers to customize the output of an existing function without modifying the function itself. These functions act as wrappers, taking another function as input and returning a modified version of it, enabling changes or extensions to the original function's behavior without altering its source code.
How Decorators Work
A decorator typically defines an inner function that calls the original function but can modify inputs, outputs, or add side effects before and/or after the call. The original function is replaced by this wrapper when the decorator is applied.
Example 1: Modifying a Function's Output
One common use of decorators is to change the return value of a function. For instance, consider a decorator that squares the output of a function:
```python def square_output(func): def wrapper(args, kwargs): result = func(args, **kwargs) return result ** 2 return wrapper
@square_output def get_number(): return 4
print(get_number()) # Output: 16 ```
In this example, is the decorator, which wraps the original function. The wrapper calls , then squares the result before returning it.
Example 2: Caching Function Results (Memoization)
Decorators can also be used to cache function results, a technique known as memoization. This approach saves previously computed results to avoid redundant calculations.
```python def memoize(func): cache = {} def wrapper(args): if args in cache: return cache[args] # Return cached result else: result = func(args) cache[args] = result # Store result in cache return result return wrapper
@memoize def slow_function(x): print(f"Computing {x}...") return x * 2
print(slow_function(4)) # Outputs "Computing 4..." then returns 8 print(slow_function(4)) # Returns 8 directly, no print ```
This approach creates a dictionary inside the decorator. On each call, it checks if the arguments are cached. If present, it returns the cached value; otherwise, it computes and caches the result.
Python's standard library provides a built-in decorator, from , which is a widely used and optimized version of such caching:
```python from functools import lru_cache
@lru_cache(maxsize=128) def fibonacci(n): if n < 2: return n return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10)) # Returns 55 with caching speeding up repeated calls ```
This decorator caches recently used calls with a limited size, evicting old entries automatically.
Summary
| Purpose | Example Decorator | Key Feature | |----------------------------|-----------------------|---------------------------------------------| | Modify output | | Alters function return value | | Cache results (memoize) | (custom) | Saves results to avoid repeated calculation | | Cache results (optimized) | | Built-in caching with eviction policy |
With Python decorators, you can change function behavior, including output modification and caching, in a powerful, flexible, and reusable manner.
Python decorators enable altering function behavior, such as modifying outputs or caching results. In the provided examples, decorators are utilized to square the output of a function and cache its results to avoid redundant computations, making them more performant. For instance, the square_output decorator modifies the output of a function, replacing get_number() with a wrapper that squares its result. Meanwhile, the memoize decorator caches function results (a technique called memoization), checking if the results are already stored and returning them directly when applicable, allowing slow_function() to return its result without recomputation.
