Caching in Python using LRU Algorithm

Caching in Python Using LRU Algorithm

Caching is a technique used to achieve fast and responsive applications by storing the results of expensive computations and reusing them when the same computations are performed again. Python’s functools module provides the lru_cache decorator, which allows you to implement caching using the Least Recently Used (LRU) strategy, making your code more efficient.

In this tutorial, you’ll learn about caching strategies and how to implement them using Python decorators. You’ll also explore the LRU strategy and its implementation with the @lru_cache decorator. Additionally, you will see how to improve performance by using this decorator and how to make it expire after a specific time.

Getting Started To use the @lru_cache decorator, you need to import it from the functools module. Below is an example of a simple function that uses the @lru_cache decorator to cache its results:

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))

In the above example, the fibonacci function uses the @lru_cache decorator to cache the results of previous calls. The maxsize argument specifies the maximum number of calls that will be cached. If maxsize is set to None (the default), the cache can grow without bound.

Combining with Other Decorators The @lru_cache decorator can be combined with other decorators to further enhance its functionality. Below is an example of combining lru_cache with a timer-based expiration decorator:

import time
from functools import lru_cache

def cached_with_expiry(expiration=5):
    def decorator(func):
        @lru_cache(maxsize=128)
        def wrapper(*args, **kwargs):
            key = (*args, frozenset(kwargs.items()))
            result = func(*args, **kwargs)
            wrapper.cache[key] = (result, time.time() + expiration)
            return result
        wrapper.cache = {}
        return wrapper
    return decorator

@cached_with_expiry(expiration=10)
def slow_function(n):
    time.sleep(n)
    return n

print(slow_function(5))

In this example, the cached_with_expiry decorator is used to add expiration functionality to the @lru_cache decorator. The slow_function is then decorated with cached_with_expiry, allowing the cached results to expire after a specific time.

Conclusion Caching is a powerful technique for improving the performance of your Python applications. The @lru_cache decorator provided by the functools module makes it easy to implement caching using the LRU strategy.

By leveraging caching in your code, you can reduce the load on computing resources and make your applications more responsive. This tutorial has provided an overview of the lru_cache decorator and demonstrated how it can be used to improve the performance of your Python code.

For more detailed information and examples, you can explore the accompanying text-based tutorial, downloadable resources, and the Q&A section of the video course.

Remember, caching is just one of the many optimization techniques available in Python, and understanding when and how to apply it can greatly enhance the performance of your applications.