Use functools' @lru_cache without specifying maxsize parameter

You have to at least call lru_cache without args:

@lru_cache()def f():    #content of the function

This way, lru_cache is initialized with default parameters.

This is because decorators in python (with the @ notation) are special functions which are evaluated and called when the interpreter is importing the module.

When you write @decorator_name you tell python that decorator_name is a function that will be called with the function (or class) defined after. Example:

@my_decoratordef function():    pass

is equivalent to:

def function():    passdecorated_function = my_decorator(function)

The lru_cache decorator is a little bit more complex because before wrapping the function, it has to create the cache (related to the function), and then wrap the function with another function that will do the cache management.Here is the (shorted) code of the CPython implementation :

def lru_cache(maxsize=128, typed=False):    # first, there is a test about the type of the parameters    if maxsize is not None and not isinstance(maxsize, int):        raise TypeError('Expected maxsize to be an integer or None')    # then, the decorating function is created, this function will be called each time you'll call the 'cached' function    def decorating_function(user_function):        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)  # in _lru_wrapper is all the magic about the cache management, it is a 2nd layer of decorator        return update_wrapper(wrapper, user_function)    return decorating_function

So, when you wrote only

@lru_cachedef f():

python called lru_cache(f), and definitively, it wasn't made to handle such thing.

To make it compliant with this write, we should add a test to check if the first parameter (maxsize) is a callable function:

def lru_cache(maxsize=128, typed=False):    # first, there is a test about the type of the parameters    if callable(maxsize):        def decorating_function(user_function):            wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)            return update_wrapper(wrapper, user_function)        return decorating_function(maxsize) # yes, maxsizeis the function in this case O:)    if maxsize is not None and not isinstance(maxsize, int):        raise TypeError('Expected maxsize to be an integer or None')    # then, the decorating function is created, this function will be called each time you'll call the 'cached' function    def decorating_function(user_function):        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)  # in _lru_wrapper is all the magic about the cache management, it is a 2nd layer of decorator        return update_wrapper(wrapper, user_function)    return decorating_function

Starting with Python 3.8+ you can use @lru_cache without parentheses, so your code snippet will work as-is

Python 3.8.0 (default, Oct 28 2019, 16:14:01) [GCC 9.2.1 20191008] on linuxType "help", "copyright", "credits" or "license" for more information.>>> import functools>>> @functools.lru_cache... def f():...     return 2... >>> 

On older versions of Python (i.e. 3.7 or below) you have to do @lru_cache(). As in, add parentheses after @lru_cache

PS. @lru_cache with no arguments implicitly sets max_size to 128. If you want to use a cache with no max size instead, on Python 3.9 you can use the new functools.cache decorator, which acts like lru_cache(max_size=None).

Think about it that way: lru_cache is a decorator factory. You call it (with or without params, but you call it) and it gives you a decorator.

Calling the decorator factory and applying the decorator on one line is the equivalent of this:

with_small_cache = lru_cache(max_size=5)@with_small_cachedef function():    ...