# functools.partial

functools.partial is one of those things that you don’t need until you need it, and then you need it badly. Trying to create a series of lambda functions I discovered that the simplest answer that came to my mind did something counter intuitive, and functools.partial – which I had ignored so far, came to my rescue.

Effectively, I wanted to create a list of functions

`f1(x), f2(x), f3(x) ...`

where each function took the same input but did something different, for example

`f1(x) = x + 1, f2(x) = x + 2, f3(x) = x + 3`

What I tried was as follows

```fl = [lambda x: x + i for i in range(4)]
```

It ran fine, but it gave me the following output

```fl[0](1) -> 4
fl[1](1) -> 4
fl[2](1) -> 4
fl[3](1) -> 4
```

What was happening was that all the lambda functions were taking the last value of i (as a global), rather than the value of i at the time the function was created.

An object oriented person would probably do something like

```class F:
def __init__(self, i):
self.i = i
def f(self, x):
return x + self.i

fl = [F(i) for i in range(4)]
```

But I enjoy Python because it borrows a lot of things from LISP and allows you to write a lot of code very succinctly, making it easier to grasp (if done well – it’s also possible to write Perl in Python)

Turns out the way you can capture the state of i in the lambda is to create a partial function, and functools.partial allows you to do this succinctly as

```fl = [functools.partial(lambda x, j: x + j, j=i) for i in range(4)]
```

For those who are curious, WHY I had to do this – well, here is an analogy to my use case: I had data that was well expressed as a table of values. The data itself was stored as a list of dictionary which was sometimes nested – some of the values formed part of a hierarchy. For example, one row of the data could look like this:

```row = {
'name': 'Baker',
'rank': 22,
'score': {
'raw': 43,
'scaled': 25
}
}```

I wanted a table with columns

```Last Name | Rank | raw score | scaled score |
----------|------|-----------|--------------|
Baker |   22 |        43 |            25|```

The actual table I was creating was meant to show ALL the data from an experiment with many variables and so had a lot of columns. I was wary of making a mistake in labeling the column relative to the value it had. It would be one of those silent and deadly errors.

If I had a simple flat structure, I might simply have changed the code such that the dictionary keys matched the column headers, weighing the fact that there was other code – already written and debugged – that used the existing keys and that the existing keys were short and succinct and I liked them.

My solution was to create a list of tuples

`[(column header, function to extract column value from dictionary)]`

And then simply loop over this list, first to create the header, and then for each row, to extract the data value into it’s correct place. Having the column header right next to the extraction function minimized the chances I would mess up somewhere, especially when adding or moving a column when editing or refactoring the code.