> For the complete documentation index, see [llms.txt](https://ricardomol.gitbook.io/notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ricardomol.gitbook.io/notes/frontend/untitled/articles/function-caching.md).

# Function caching

Allows us to **cache the return values of a function depending on the arguments.**

It can **save time** when an I/O bound function is periodically called with the same arguments. 

Before Python 3.2 we had to write a custom implementation. In **Python 3.2+** there is an **`lru_cache`decorator which allows us to quickly cache and uncache the return values of a function**.

## Python 3.2+

Example: Fibonacci calculator with `lru_cache`.

```python
from functools import lru_cache

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

>>> print([fib(n) for n in range(10)])
# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
```

The `maxsize` argument tells `lru_cache` about **how many recent return values to cache**.

We can **uncache the return values**:

```python
fib.cache_clear()
```

## Python 2+

There are a couple of ways to achieve the same effect. You can create any type of caching mechanism. It entirely depends upon your needs. Here is a generic cache:

```python
from functools import wraps

def memoize(function):
    memo = {}
    @wraps(function)
    def wrapper(*args):
        try:
            return memo[args]
        except KeyError:
            rv = function(*args)
            memo[args] = rv
            return rv
    return wrapper

@memoize
def fibonacci(n):
    if n < 2: return n
    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(25)
```

**Note:** memoize won’t cache **unhashable types (dict, lists, etc…)** but only the immutable types. Keep that in mind when using it.

## Further reading

[Here](https://www.caktusgroup.com/blog/2015/06/08/testing-client-side-applications-django-post-mortem/) is a fine article by Caktus Group in which they caught a bug in Django which occurred due to `lru_cache`.&#x20;