Sep 10th, 2021 - written by Kimserey with .
Partial function application is a useful tool to reduce the signature of a function by fixing the first arguments which then result in a new function with the remaining arguments. In this post, we will see when partial application is useful in Python and how we can implement it.
Partial application is the process of fixing a number of arguments of a function. This then creates a new function taking the remaining arguments as parameter.
Using this method, we can create reduce the complexity of functions with multiple arguments by creating sub-functions which have a tighter scope by fixing the first arguments.
Partial application can be achieve using
1 >>> from functools import partial
For example let’s consider an addition function:
1 2 3 4 5 6 7 >>> def add(x, y): return x + y >>> add_to_two = partial(add, 2) >>> add_to_two(3) >>> 5
Here we have a function
add taking two arguments
y. We partially apply it by setting
2 which result in a function taking a single argument.
Because we’ve set the first argument, we have reduced the complexity of the function by making it’s scope smaller - here the function nows adds
2 to any number provided.
Partial application can also be achieved on methods.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 >>> from functools import partialmethod >>> class A: def __init__(self): self._value = 0 @property def value(self): return self._value def set_value(self, value): self._value = value set_two = partialmethod(set_value, 2)
In this example, we have created a class
A with a
value property, and a
set_value method. By using
partialmethod, we are able to set the argument of
set_value and create
set_two no longer takes any arguments:
1 2 3 4 5 6 7 8 9 >>> a = A() >>> a.value >>> 0 >>> a.set_two() >>> a.value >>> 2
We can see that calling
set_two has set
reduce is a good example where partial application comes handy.
reduce is also available from
functools, taking a function as first argument and an iterable as second argument, it folds the iterable over by continuously calling the first argument feeding back to it it’s own result as first argument.
1 2 3 4 >>> from functools import reduce >>> reduce(lambda acc, cur: acc + cur, [1, 2, 3, 4]) >>> 10
For example here, we use an addition to compute the sum of the list
[1, 2, 3, 4]. Using
reduce and combining it with
partial, we can then fix the first argument (the lambda) and create a simplified version:
1 2 3 4 5 6 7 >>> partial >>> functools.partial >>> new_sum = partial(reduce, lambda acc, cur: acc + cur) >>> new_sum([1, 2, 3, 4]) >>> 10
Here we’ve created a sum function
new_sum by partially applying our addition as first argument of
reduce. And that concludes today’s post!
In this post, we looked into how we could use
partialmethod to partially apply argument to functions. And we finished with a concrete example using
reduce where we partially applied the first argument to create a new function. I hope you liked this post and I see you on the next one!