Transforming iterables


Martin McBride, 2018-10-18
Tags higher order function map filter lambda function iterator built-in function
Categories functional programming

This article is part of a series on functional programming.

Higher order functions are functions that act on other functions.

Two important built-in Python higher order functions - map and filter.

map

map applies a function to each element in an iterable, and returns the results as a new iterable.

Here is an example:

import math

k = [1, 25, 81]
e = map(math.sqrt, k)

print(list(e))         #[1.0, 5.0, 9.0]

In this case the map function applies the sqrt function to each of the elements in the list [1, 25, 81]. The result is a sequence containing the values 1.0, 5.0 and 9.0 (the square roots of the numbers in the original list). Note that map creates an iterator - we must convert it to a list before we can print it.

The code above is roughly equivalent to this loop:

import math

k = [1, 25, 81]
e = []
for x in k:
    e.append(math.sqrt(x))

print(e)         #[1.0, 5.0, 9.0]

The main benefit of using map is that it makes the intent clear. Although the loop in the second example is very simple, you still need to read it to understand what it is doing, because a loop could be doing various different things.

It also makes the code shorter and simpler, so it is less likely to contain bugs.

Finally, map uses lazy evaluation, so that it never needs to store all the elements of the output in memory. If k was a very long list, it could be useful to be able to process it one item at a time so save memory.

filter

filter accepts a predicate and an iterable. A predicate is any function that accepts a single parameter and return a boolean result.

filter applies the predicate to each item in the input iterable, and returns a new iterable that contains only those items for which the predicate returns True.

For example:

def gt_0(x):
    return x > 0

k = [1, -2, 3, 2, 0, -1]
f = filter(gt_0, k)

Here our predicate accepts only value that are greater than 0, so f contains the sequence:

1, 3, 2

For more examples see Looping over selected items.

Using lambdas

In the filter example above, we declared a function gt_0 that only gets used is the filter call. We could avoid creating a function by using a lambda function. This allows a simple function to be defined where it is used, without needing to name it (it is an anonymous function). We can define a lambda version of gt_0 like this:

lambda x : x > 0

Or code would now look like:

k = [1, -2, 3, 2, 0, -1]
f = filter(lambda x : x > 0, k)

See also

If you found this article useful you might be interested in my ebook Functional Programming in Python.


Tag cloud

2d arrays abstract data type alignment and array arrays bezier curve built-in function close closure colour comparison operator comprehension context conversion data types design pattern device space dictionary duck typing efficiency encryption enumerate filter font font style for loop function function composition function plot functools generator gif gradient higher order function html image processing imagesurface immutable object index inner function input installing iter iterator itertools lambda function len linspace list list comprehension logical operator lru_cache mandelbrot map monad mutability named parameter numeric python numpy object open operator optional parameter or partial application path positional parameter print pure function radial gradient range recursion reduce rotation scaling sequence slice slicing sound spirograph str stream string subpath symmetric encryption template text text metrics transform translation transparency tuple unpacking user space vectorisation webserver website while loop zip

Copyright (c) Axlesoft Ltd 2020