Python Higher-Order Functions: map, filter, reduce, sorted, any/all, enumerate, zip, reversed, list/dict/set, and lambda

1. map(): batch processing data – The map() function applies a given function to each element of an iterable, returning a new iterator.

numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # Output: [1, 4, 9, 16]

2. filter(): select elements that meet a condition – filter() keeps only those items for which the provided function returns True .

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # Output: [2, 4]

3. reduce(): cumulative computation – reduce() (from functools ) aggregates elements of an iterable using a binary function.

from functools import reduce
numbers = [1, 2, 3, 4]
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_of_numbers)  # Output: 10

4. sorted(): sorting with custom keys – sorted() returns a new sorted list and can accept a key function to define ordering.

words = ['apple', 'banana', 'cherry', 'date']
sorted_words = sorted(words, key=len)
print(sorted_words)  # Output: ['date', 'apple', 'cherry', 'banana']

5. any() and all(): logical checks – any() returns True if at least one element is truthy; all() returns True only if every element is truthy.

nums = [0, 0, 0, 1]
has_non_zero = any(nums)
print(has_non_zero)  # Output: True

6. enumerate(): index‑element pairing – enumerate() yields pairs of index and element, useful in loops.

fruits = ['apple', 'banana', 'mango']
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

7. zip(): merging iterators – zip() aggregates elements from multiple iterables into tuples.

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
people = list(zip(names, ages))
print(people)  # Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

8. reversed(): reverse iteration – reversed() returns an iterator that yields items in reverse order.

numbers = [1, 2, 3, 4, 5]
print(list(reversed(numbers)))  # Output: [5, 4, 3, 2, 1]

9. list(), dict(), set(): constructing containers – These functions convert any iterable into a list, dictionary, or set respectively.

tuples = [(1, 'apple'), (2, 'banana')]
dictionary = dict(tuples)
print(dictionary)  # Output: {1: 'apple', 2: 'banana'}

10. lambda expressions: anonymous functions – lambda creates small, unnamed functions, often used as arguments to higher‑order functions.

sum_lambda = lambda x, y: x + y
print(sum_lambda(3, 5))  # Output: 8

Conclusion – Higher‑order functions are powerful tools in Python that simplify code, improve readability, and enable functional programming techniques; mastering them unlocks many possibilities for clean and efficient programming.