Functional-style programming is an approach to programming where computations are built up from combining functions that don’t modify their arguments and that don’t refer to or change the program’s state, and that provide their results as return values. One strong appeal of this kind of programming is that (in theory), it is much easier to develop functions in isolation and to debug functional programs. This is helped by the fact that functional programs don’t have state changes, so it is possible to reason about their functions mathematically.

Three concepts that are strongly associated with functional programming are mapping, filtering, and reducing. Mapping involves taking a function and an iterable and producing a new iterable (or a list) where each item is the result of calling the function on the corresponding item in the original iterable. This is supported by the built-in map() function, for example:

The map() function takes a function and an iterable as its arguments and for efficiency it returns an iterator rather than a list. Here we forced a list to be created to make the result clearer:

A generator expression can often be used in place of map(). Here we have used a list comprehension to avoid the need to use list(); to make it a generator we just have to change the outer brackets to parentheses.

Filtering involves taking a function and an iterable and producing a new iterable where each item is from the original iterable—providing the function returns True when called on the item. The built-in filter() function supports this:

The filter() function takes a function and an iterable as its arguments and returns an iterator.

The filter() function can always be replaced with a generator expression or with a list comprehension.

Reducing involves taking a function and an iterable and producing a single result value. The way this works is that the function is called on the iterable’s first two values, then on the computed result and the third value, then on the computed result and the fourth value, and so on, until all the values have been used. The functools module’s functools.reduce() function supports this. Here are two lines of code that do the same computation:

The operator module has functions for all of Python’s operators specifically to make functional-style programming easier. Here, in the second line, we have used the operator.mul() function rather than having to create a multiplication function using lambda as we did in the first line.

Python also provides some built-in reducing functions: all(), which given an iterable, returns True if all the iterable’s items return True when bool() is applied to them; any(), which returns True if any of the iterable’s items is True; max(), which returns the largest item in the iterable; min(), which returns the smallest item in the iterable; and sum(), which returns the sum of the iterable’s items.

Now that we have covered the key concepts, let us look at a few more examples. We will start with a couple of ways to get the total size of all the files in list files:

Using map() is often shorter than the equivalent list comprehension or generator expression except where there is a condition. We’ve used operator.add() as the addition function instead of lambda x, y: x + y.

If we only wanted to count the .py file sizes we can filter out non-Python files. Here are three ways to do this:

Arguably, the second and third versions are better because they don’t require us to create a lambda function, but the choice between using generator expressions (or list comprehensions) and map() and filter() is most often purely a matter of personal programming style.

Using map(), filter(), and functools.reduce() often leads to the elimination of loops, as the examples we have seen illustrate. These functions are useful when converting code written in a functional language, but in Python we can usually replace map() with a list comprehension and filter() with a list comprehension with a condition, and many cases of functools.reduce() can be eliminated by using one of Python’s built-in functional functions such as all(), any(), max(), min(), and sum(). For example:

This achieves the same thing as the previous three examples, but is much more compact.

In addition to providing functions for Python’s operators, the operator module also provides the operator.attrgetter() and operator.itemgetter() functions, the first of which we briefly met earlier in this short cut. Both of these return functions which can then be called to extract the specified attributes or items.

Whereas slicing can be used to extract a sequence of part of a list, and slicing with striding can be used to extract a sequence of parts (say, every third item with L[::3]), operator.itemgetter() can be used to extract a sequence of arbitrary parts, for example, operator.itemgetter(4, 5, 6, 11, 18)(L). The function returned by operator.itemgetter() does not have to be called immediately and thrown away as we have done here; it could be kept and passed as the function argument to map(), filter(), or functools.reduce(), or used in a dictionary, list, or set comprehension.

When we want to sort we can specify a key function. This function can be any function, for example, a lambda function, a built-in function or method (such as str.lower()), or a function returned by operator.attrgetter(). For example, assuming list L holds objects with a priority attribute, we can sort the list into priority order like this: L.sort(key=operator.attrgetter("priority")).

In addition to the functools and operator modules already mentioned, the iter-tools module can also be useful for functional-style programming. For example, although it is possible to iterate over two or more lists by concatenating them, an alternative is to use itertools.chain() like this:

The itertools.chain() function returns an iterator that gives successive values from the first sequence it is given, then successive values from the second sequence, and so on until all the values from all the sequences are used. The itertools module has many other functions and its documentation gives many small yet useful examples and is well worth reading.