A Primer on Python Partial Functions
Tags: python, functional
Published: 2019-11-25 18:03:28

Partial functions are one of the most "terrifying concepts" I hear people talking about. Personally, I think the idea is fairly easy to grasp. That is, I will try to explain in a few paragraphs with python and help you escape the math labyrinth of "official documentation".

## What is a partial function

Partial functions are a computer science concept where we can derive a function with x parameters to a function with fewer parameters and constant values set for the more limited function.

They became more mainstream, as functional programming arose and the main pillars of it (map, filter, reduce, etc), require functions as an argument.

Let's break this down

## An example

Searching the official python documentation I found this example:

```
>>> from functools import partial
>>> basetwo = partial(int, base=2)
>>> basetwo.__doc__ = 'Convert base 2 string to an int.'
>>> basetwo('10010')
18
```

So, we have function `int` which, as you can imagine, takes an argument (number or string) and converts it to an integer (if technically possible). This function also takes various arguments. One of them is `base`.

Don't worry about the `__doc__` thing, it is the message that is printed when you asked for the documentation of the function.

So in the example above, we invoke the `partial` factory, to derive a new (more specialized) function from the `int` one.

## Why don't we just use default arguments?

Interesting question, thanks for asking. The difference between the example above and your proposal is that calling 
`int('110', base=2)` will return an **integer** or in general the **result of the execution** of the function.

`basetwo` on the other hand, is a function reference, which in turn you can use it as input for more partial functions or to functions that get other functions as arguments eg `map`.

## So is this like overloading and overriding?

Overloading is when you have one function, with the same name but a different signature. When you create a partial function, you give the function a different name (unless you want for some reason to shadow the original one).

Overriding, on the other hand, refers to a language feature that allows a subclass to provide a specific implementation of a method that is already provided by one of its super-classes. Partial functions provide specialized versions of initial functions but that usually is under a different name and for sure it is not bound to inheritance trees

## I see, so it is just a function that modifies functions on the fly

You can say it this way, too.

Based on the python examples again, this is how the partial factory would look like:

```
def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*args, *fargs, **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc
```

Given a function(`func`) and a set of values(`*args`, `**keywords`), it creates a new function (`newfunc`) which performs some business logic by invoking the passed function (`func`) and potentially using `*args`, `**keywords`.

## Conclusion

Thank you for reading this short article and I hope it was helpful to you. Let me know your thoughts in the comments.