Python provides several functional programming tools that allow you to write concise, expressive code. Let’s explore lambda, map, filter, and the functools module.
Small anonymous functions can be created with the lambda keyword. Lambda functions can be used wherever function objects are required. They are syntactically restricted to a single expression.
add = lambda x, y: x + y
print(add(5, 3))8
You can use lambdas as sorting keys:
users = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]
users_sorted = sorted(users, key=lambda u: u['age'])
print([u['name'] for u in users_sorted])['Bob', 'Alice']
map() returns an iterator that applies a function to every item of an iterable, yielding the results.
nums = [1, 2, 3]
squares = map(lambda x: x**2, nums)
print(list(squares))[1, 4, 9]filter() constructs an iterator from those elements of an iterable for which a function is true.
nums = [1, 2, 3, 4]
evens = filter(lambda x: x % 2 == 0, nums)
print(list(evens))[2, 4]
Combining map and filter:
nums = [1, 2, 3, 4]
res = map(lambda x: x * 3, filter(lambda x: x % 2 == 0, nums))
print(list(res))[6, 12]
The functools module provides higher-order functions. reduce() applies a function of two arguments cumulatively to the items of an iterable, from left to right, reducing the iterable to a single value.
from functools import reduce
nums = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, nums)
print(product)24
partial() returns a new partial object which when called behaves like func called with the positional arguments and keyword arguments pre-filled.
from functools import partial
def power(base, exp):
return base ** exp
square = partial(power, exp=2)
print(square(5))25
Is the following statement true or false? 'lambda functions are faster than regular def functions.'
False — Lambda functions are just syntactic sugar for a normal function definition. They have exactly the same execution speed.
Is the following statement true or false? 'map and filter return lists in Python 3.'
False — In Python 3, map() and filter() return iterators, not lists. You must wrap them in list() if you need a physical list, or iterate over them.
Is the following statement true or false? 'A lambda can contain multiple expressions or statements.'
False — A lambda is strictly limited to a single expression and cannot contain statements like print or return.
Use `filter()` to keep only odd numbers from `data`, and then `map()` to triple them. Finally, convert the result to a list.
data = [1, 2, 3, 4, 5]
result = list(map(lambda x: x * 3, filter(lambda x: x % 2 != 0, data)))
print(result)Use `functools.reduce()` and a `lambda` to find the maximum value in `numbers`.
from functools import reduce
numbers = [10, 42, 17, 99, 23]
maximum = reduce(lambda a, b: a if a > b else b, numbers)
print(maximum)Bug Hunt! The code below tries to print the `squares` map object twice. But the second print outputs an empty list because the iterator is exhausted. Fix the code so it correctly prints the squared list twice.
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x*x, nums))
print("First time:", squares)
print("Second time:", squares)