What is Python caching?

Introduction

Imagine if you could make your Python programs run much faster without much effort. That's what caching can do for you. Think of Python caching as a way to save the answers to difficult problems so you don't have to solve them again. By keeping these answers handy, your programs can skip the heavy lifting and get results quickly.

When using pcaching, the results of time-consuming calculations are stored. The next time the program needs that result, it can simply retrieve it from storage instead of performing the calculation again. This not only speeds up the code, but also makes it easier to manage complex tasks.

In this article, we will learn how to use this powerful technique to supercharge your code and achieve smoother and faster Python experiences.

General description

• Understand the concept and benefits of caching in Python applications.
• Implement caching using Python's built-in functools.lru_cache decorator.
• Build custom caching solutions using dictionaries and external libraries like cachetools.
• Apply caching techniques to optimize database queries and API calls to improve performance.

What is caching?

Caching involves saving the results of expensive or frequently executed operations so that subsequent calls with the same parameters can return the cached results instead of recomputing them. This reduces time complexity, especially for functions with high computational costs or those that are called repeatedly with the same inputs.

When to use caching

Caching is beneficial in situations where:

• It has functions with expensive calculations.
• Functions are called multiple times with the same arguments.
• The results of the function are immutable and deterministic.

Implementing caching in Python

Python's functools module provides a built-in caching decorator called lru_cache, which stands for least recently used cache. It is easy to use and very effective for many use cases.

Using functools.lru_cache

Here's how you can use lru_cache to cache function results:

Import the decorator

from functools import lru_cache

Apply the decorator

Applies lru_cache to a function to cache its return values.

@lru_cache(maxsize=128)
def expensive_function(x):
    # Simulate an expensive computation
    result = x * x
    return result

maxsize specifies the number of results to be cached. Once this limit is reached, the least recently used result is discarded. If maxsize=None is set, the cache can grow indefinitely.

Example of use

import time
@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
start_time = time.time()
print(fibonacci(35))  # First call will take longer
print("First call took", time.time() - start_time, "seconds")
start_time = time.time()
print(fibonacci(35))  # Subsequent calls are much faster
print("Second call took", time.time() - start_time, "seconds")

Custom caching solutions

For more complex scenarios, you may need custom caching solutions. Python offers several libraries and techniques for creating custom caches:

Using a dictionary

cache = {}
def expensive_function(x):
    if x not in cache:
        cache(x) = x * x  # Simulate an expensive computation
    return cache(x)

Using caching tools

The cachetools library provides a variety of cache types and is more flexible than lru_cache.

from cachetools import cached, LRUCache
cache = LRUCache(maxsize=128)
@cached(cache)
def expensive_function(x):
    return x * x  # Simulate an expensive computation

Practical application

• Database queries: Caching database query results can significantly reduce database load and improve response times.

query_cache = {}
def get_user_data(user_id):
    if user_id not in query_cache:
        # Simulate a database query
        query_cache(user_id) = {"name": "John Doe", "age": 30}
    return query_cache(user_id)

• API Calls: Cache API call results to avoid hitting rate limits and reduce latency.

import requests
api_cache = {}
def get_weather(city):
    if city not in api_cache:
        response = requests.get(f'http://api.weather.com/{city}')
        api_cache(city) = response.json()
    return api_cache(city)

Conclusion

Caching is a mechanism to optimize Python code, especially when it comes to expensive calculations and non-recurring function calls. We can use it to build our cache easily using tools already available in Python, such as functools.lry_cache or other custom forms of caching; huge gains in application performance can be achieved. Caching is an effective tool to save time and resources, whether you are optimizing database queries or API calls (as we will do in this example), computational functions, etc.

Frequent questions