Chapter 5Writing higher-order functions
We can identify three varieties of higher-order functions; they are as follows:
- Functions that accept a function as one of its arguments.
- Functions that return a function. A Callable class is a common example of
this. A function that returns a generator expression can be thought of as a
higher-order function. - Functions that accept and return a function. The functools.partial()
function is a common example of this. We'll save this for Chapter 10, The
Functools Module. A decorator is different; we'll save this for Chapter 11,
Decorator Design Techinques.
We'll expand on these simple patterns using a higher-order function to also
transform the structure of the data. We can do several common transformations
such as the following:
- Wrap objects to create more complex objects
- Unwrap complex objects into their components
- Flatten a structure
- Structure a flat sequence
A Callable class object is a commonly used example of a function that returns a
callable object. We'll look at this as a way to write flexible functions into which
configuration parameters can be injected.
We'll also introduce simple decorators in this chapter. We'll defer deeper
consideration of decorators until Chapter 11, Decorator Design Techniques.
Writing higher-order mappings and filters
Python's two built-in higher-order functions, map() and filter(), generally handle
almost everything we might want to throw at them. It's difficult to optimize them in
a general way to achieve higher performance. We'll look at functions of Python 3.4,
such as imap(), ifilter(), and ifilterfalse(), in Chapter 8, The Itertools Module.
We have three largely equivalent ways to express a mapping. Assume that we
have some function, f(x), and some collection of objects, C. We have three entirely
equivalent ways to express a mapping; they are as follows:
- The map() function:
map(f, C)