Higher Order Functions in Python

In Python, Higher Order Functions (HOFs) play an important role in functional programming and allow for writing more modular, reusable and readable code. A Higher-Order Function is a function that either:

• Takes another function as an argument
• Returns a function as a result

Example:

HELLO

Explanation: greet(func) is a higher-order function as it takes another function as an argument. uppercase(text) converts text to uppercase. Calling greet(uppercase) passes "Hello" to uppercase, resulting in "HELLO".

Examples of Higher Order Functions

Example 1 : Passing a functions as an arguments

A function can be passed as an argument to another function, enabling dynamic behavior.

25

Explanation:

• apply(func, x) takes another function as an argument.
• square(n) computes the square of n.
• apply(square, 5) executes square(5), resulting in 25.

Example 2: Returning a function

A Higher-Order Function can return another function, allowing function generation dynamically.

10
15

Explanation:

• fun(n) returns a lambda function that multiplies a number by n.
• double and triple are function instances that multiply by 2 and 3, respectively.
• Calling double(5) results in 5 * 2 = 10 and triple(5) results in 5 * 3 = 15.

Built in Higher Order Functions in Python

Python provides several built-in Higher Order Functions such as map(), filter() and sorted(), which simplify operations on iterable objects.

map()

A higher-order function that takes another function as an argument and applies it to each element in an iterable, enabling transformation without explicit loops.

[1, 4, 9, 16]

Explanation: map(func, iterable) applies func to each element in iterable and lambda x: x ** 2 squares each number in the list.

filter()

A higher-order function that accepts a function to evaluate each element, returning only those that satisfy the given condition.

[2, 4, 6]

Explanation: filter(func, iterable) applies func to filter elements satisfying the condition and lambda x: x % 2 == 0 retains only even numbers.

sorted()

A higher-order function that sorts elements based on a provided key function, allowing custom sorting logic.

['java', 'python', 'javascript']

Explanation: sorted(iterable, key=func) sorts based on func applied to each element and key=len sorts the strings by length.

Applications of Higher order functions

They are widely used in functional programming, closures, decorators, and callbacks to improve code modularity, reusability and abstraction. Let's explore the applications of higher-order functions.

Using closure

Closures allow functions to remember and use variables from their parent scope even after the parent function has finished running. This makes them essential for higher-order functions, enabling tasks like combining multiple functions , storing previous results for faster performance, breaking functions into smaller and efficiently handling arrays.

Example:

6
7
11

Explanation:

• counter(start=0) returns increment, a closure that retains access to the enclosed count variable, allowing it to persist and update across calls.
• increment() retains access to count, modifies it using nonlocal and increments it by 1 on each call. counter() returns increment, allowing it to be called later.
• counter(5) creates counter1 with count = 5. The first call increments it to 6 and the second call increases it to 7.
• counter(10) initializes counter2 with count = 10. Calling counter2() increments it to 11, independent of counter1.

Using decorator

Decorators extend or modify functions without changing their original code by wrapping them inside another function. They enhance higher-order functions by enabling tasks like caching results, controlling access (authentication), transforming inputs/outputs and tracking function calls.

Example:

Before function execution
Inside the function!
After function execution

Explanation:

• decor(func) returns wrap, a closure that modifies func's behavior.
• wrap() prints messages before and after calling func().
• func = decor(func) replaces func with wrap, adding extra functionality.
• Calling func() now executes wrap(), printing messages and running func().