1

@functools.cache(user_function)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import functools
@functools.cache
def feb(n):
    print('calling n: ', n)
    return feb(n-1) + feb(n-2) if n > 2 else 1
print(feb(8))
print(feb(4))
print(feb(10))
-->
calling n:  8
calling n:  7
calling n:  6
calling n:  5
calling n:  4
calling n:  3
calling n:  2
calling n:  1
21
3
calling n:  10
calling n:  9
55

1

@functools.cached_property(func)

1
2
3
4
5
6
7
8
9
10

import functools
class DataSet:
    def __init__(self, sequence_of_numbers):
        self._data = tuple(sequence_of_numbers)
    @functools.cached_property
    def stdev(self):
        return statistics.stdev(self._data)

1

functools.cmp_to_key(func)

1

sorted(iterable, key=cmp_to_key(locale.strcoll))  # locale-aware sort order

1
2

@functools.lru_cache(user_function)
@functools.lru_cache(maxsize=128, typed=False)

1
2
3
4
5
6
7
8
9

@lru_cache(maxsize=32)
def get_pep(num):
    'Retrieve text of a Python Enhancement Proposal'
    resource = 'https://peps.python.org/pep-%04d/' % num
    try:
        with urllib.request.urlopen(resource) as s:
            return s.read()
    except urllib.error.HTTPError:
        return 'Not Found'

1

@functools.total_ordering

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@total_ordering
class Student:
    def _is_valid_operand(self, other):
        return (hasattr(other, "lastname") and
                hasattr(other, "firstname"))
    def __eq__(self, other):
        if not self._is_valid_operand(other):
            return NotImplemented
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))
    def __lt__(self, other):
        if not self._is_valid_operand(other):
            return NotImplemented
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import functools
def show(A, B, C='test'):
    print("A: ", A)
    print("B: ", B)
    print("C: ", C)
new_show = functools.partial(show, 'ABC', C='partial input')
new_show(3)
pass
-->
A:  ABC
B:  4
C:  partial input

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Cell:
    def __init__(self):
        self._alive = False
    @property
    def alive(self):
        return self._alive
    def set_state(self, state):
        self._alive = bool(state)
    set_alive = partialmethod(set_state, True)
    set_dead = partialmethod(set_state, False)
c = Cell()
c.alive
-->
False
c.set_alive()
c.alive
-->
True

1

functools.reduce(function, iterable[, initializer])

1

reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

from functools import singledispatch
@singledispatch
def fun(arg, verbose=False):
    if verbose:
        print("Let me just say,", end=" ")
    print(arg)
@fun.register
def _(arg: int, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)
@fun.register
def _(arg: list, verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)
# types.UnionType and typing.Union can also be used:
@fun.register
def _(arg: int | float, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)
from typing import Union
@fun.register
def _(arg: Union[list, set], verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)
@fun.register(float)
@fun.register(Decimal)
def fun_num(arg, verbose=False):
    if verbose:
        print("Half of your number:", end=" ")
    print(arg / 2)
fun_num is fun

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

fun("Hello, world.")
 	Hello, world.
fun("test.", verbose=True)
	Let me just say, test.
fun(42, verbose=True)
	Strength in numbers, eh? 42
fun(['spam', 'spam', 'eggs', 'spam'], verbose=True)
	Enumerate this:
	0 spam
	1 spam
	2 eggs
	3 spam
fun(None)
	Nothing.
fun(1.23)
	0.615

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Negator:
    @singledispatchmethod
    def neg(self, arg):
        raise NotImplementedError("Cannot negate a")
    @neg.register
    def _(self, arg: int):
        return -arg
    @neg.register
    def _(self, arg: bool):
        return not arg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Negator:
    @singledispatchmethod
    @classmethod
    def neg(cls, arg):
        raise NotImplementedError("Cannot negate a")
    @neg.register
    @classmethod
    def _(cls, arg: int):
        return -arg
    @neg.register
    @classmethod
    def _(cls, arg: bool):
        return not arg

1

functools.update_wrapper(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)

1

@functools.wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from functools import wraps
def my_decorator(f):
    @wraps(f)
    def wrapper(*args, **kwds):
        print('Calling decorated function')
        return f(*args, **kwds)
    return wrapper
@my_decorator
def example():
    """Docstring"""
    print('Called example function')
-->
example()
	Calling decorated function
	Called example function
example.__name__
	'example'
example.__doc__
	'Docstring'