Memoization Using Decorators In Python

Explore how to enhance Python function efficiency with memoization using decorators. Learn to cache results for faster execution on repetitive calls.

Memoization in Python, achieved using decorators, is a technique that stores the results of expensive function calls and returns the cached result when the same inputs occur again. This optimization reduces computation time significantly by avoiding repeated calculations. Decorators wrap a function, managing the cache mechanism seamlessly, thus enhancing efficiency in recursive and intensive computation tasks.

Memoization using decorators in Python is an effective technique for optimizing the performance of functions by caching the results of expensive function calls. This approach uses decorators to wrap a function, storing its results in a cache based on its arguments, and returning the cached result for subsequent calls with the same arguments.

Implementing memoization with decorators involves creating a decorator function that holds a cache (usually a dictionary). When the decorated function is called, the decorator checks if the function's arguments are already in the cache. If so, it returns the cached result. Otherwise, it executes the function, caches the result, and then returns it.


def memoize(func):
    cache = {}
    def memoized_func(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return memoized_func

def fibonacci(n):
    if n in [0, 1]:
        return n
    return fibonacci(n-1) + fibonacci(n-2)




This code demonstrates memoization on the Fibonacci sequence calculation, significantly reducing the number of computations by caching previously computed values. The @memoize decorator automatically handles the caching, making the fibonacci function more efficient for large inputs.

You can also check these blogs:

  1. Python OOPs Concepts