141. Decorators for Caching Results

Using decorators like functools.lru_cache in Python allows you to cache the results of expensive function calls, thus improving the performance of the application by avoiding repeated computation for the same inputs. Here are 10 Python snippets for using caching decorators, particularly lru_cache and custom decorators for caching results.

1. Basic Caching with lru_cache

Using lru_cache to cache results of a function based on its arguments.

Copy

from functools import lru_cache

@lru_cache(maxsize=None)  # Unlimited cache size
def expensive_computation(n):
    print(f"Computing {n}...")
    return n * n

# First call, performs the computation
print(expensive_computation(4))  
# Second call, retrieves from cache
print(expensive_computation(4))  

Output:

Copy

Computing 4...
16
16

Explanation:

• The first time expensive_computation(4) is called, it performs the calculation and caches the result.

• The second time the same value is requested, the cached result is returned, avoiding the computation.

2. Caching with lru_cache with a Limited Cache Size

Using lru_cache with a specified maximum cache size.

Copy

from functools import lru_cache

@lru_cache(maxsize=3)  # Cache stores up to 3 results
def expensive_computation(n):
    print(f"Computing {n}...")
    return n * n

# Calls that will be cached
print(expensive_computation(1))
print(expensive_computation(2))
print(expensive_computation(3))

# Calls that will evict the oldest cached result
print(expensive_computation(4))
print(expensive_computation(2))  # Cache miss, will be recomputed

Output:

Copy

Computing 1...
Computing 2...
Computing 3...
Computing 4...
16
4
9
16
4

Explanation:

• The cache holds a maximum of 3 results. Once more results are added, the least recently used results are evicted.

3. Caching with Custom Decorators

You can implement a custom caching decorator if you want more control over the cache.

Copy

def cache_decorator(func):
    cache = {}
    def wrapper(*args):
        if args not in cache:
            print(f"Computing result for {args}...")
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@cache_decorator
def expensive_computation(n):
    return n * n

# Calls that will be cached
print(expensive_computation(4))
print(expensive_computation(4))  # Cache hit

Output:

Copy

Computing result for (4,)...
16
16

Explanation:

• The cache_decorator manually caches results based on the arguments passed to the function.

4. Caching Function Results with lru_cache for Fibonacci Numbers

A classic example of using lru_cache for improving performance when calculating Fibonacci numbers.

Copy

from functools import lru_cache

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

# First call, computes Fibonacci numbers
print(fibonacci(35))
# Second call, retrieves from cache
print(fibonacci(35))

Output:

Copy

9227465
9227465

Explanation:

• The recursive fibonacci function benefits from lru_cache by caching previously computed Fibonacci numbers, significantly improving performance.

5. Caching with Function Arguments as Keys

You can use lru_cache with arguments that are hashable and work efficiently for caching.

Copy

from functools import lru_cache

@lru_cache(maxsize=None)
def concat_strings(a, b):
    return a + b

# Caching function with string arguments
print(concat_strings("Hello", " World"))
print(concat_strings("Hello", " World"))  # Cache hit

Output:

Copy

Hello World
Hello World

Explanation:

• The concat_strings function concatenates two strings and caches the result based on the argument values.

6. Memoization for Repeated Function Calls

Use caching to optimize functions that are called repeatedly with the same arguments.

Copy

from functools import lru_cache

@lru_cache(maxsize=5)
def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

print(factorial(5))  # Computes and caches result
print(factorial(5))  # Retrieves result from cache

Output:

Copy

120
120

Explanation:

• The factorial function benefits from caching, as repeated calls with the same argument don't require recomputation.

7. Clearing the Cache Manually

You can clear the cache manually when needed.

Copy

from functools import lru_cache

@lru_cache(maxsize=3)
def square(n):
    return n * n

print(square(3))
print(square(4))
square.cache_clear()  # Manually clear the cache
print(square(3))  # Cache miss after clearing

Output:

Copy

9
16
9

Explanation:

• The cache_clear() method clears the cache manually, causing the next call to recompute the result.

8. Conditional Caching

You can apply caching only under certain conditions, like the length of the argument list.

Copy

from functools import lru_cache

@lru_cache(maxsize=3)
def compute_something(n):
    if n < 5:
        return n * n
    else:
        return n ** 2

# Calls that will be cached
print(compute_something(4))
print(compute_something(6))
print(compute_something(4))  # Cache hit

Output:

Copy

16
36
16

Explanation:

• The function caches results based on the conditions set inside the decorator.

9. Caching Results in Web Applications

In web applications, caching helps with storing frequently requested resources to improve speed.

Copy

from functools import lru_cache

@lru_cache(maxsize=10)
def get_user_profile(user_id):
    # Simulate a database call
    return f"User profile for {user_id}"

print(get_user_profile(1))
print(get_user_profile(1))  # Cache hit

Output:

Copy

User profile for 1
User profile for 1

Explanation:

• In web apps, functions like database queries can be cached to avoid querying the database multiple times for the same data.

10. Custom Cache Timeout

Implementing a custom cache timeout mechanism to invalidate cached values after a certain period.

Copy

import time
from functools import wraps

def cache_with_timeout(timeout=5):
    def decorator(func):
        cache = {}
        cache_time = {}

        @wraps(func)
        def wrapper(*args):
            current_time = time.time()
            if args in cache and current_time - cache_time[args] < timeout:
                return cache[args]
            result = func(*args)
            cache[args] = result
            cache_time[args] = current_time
            return result
        return wrapper
    return decorator

@cache_with_timeout(timeout=2)
def slow_function(n):
    print(f"Computing {n}...")
    time.sleep(1)
    return n * n

print(slow_function(3))  # Computation
time.sleep(1)
print(slow_function(3))  # Cache hit
time.sleep(2)
print(slow_function(3))  # Cache miss (timeout)

Output:

Copy

Computing 3...
9
9
Computing 3...
9

Explanation:

• The custom cache_with_timeout decorator stores the result for a specified timeout. After the timeout expires, the cache is invalidated, and the function is recomputed.

---

Conclusion:

Caching with decorators like lru_cache and custom caching mechanisms can greatly improve performance by preventing redundant calculations. These examples demonstrate different ways to apply caching to functions based on various use cases, from simple memoization to more complex custom timeout-based caches.