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:

def greet(func): # higher-order function 
    return func("Hello")

def uppercase(text): # function to be passed
    return text.upper()

print(greet(uppercase))

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.

def apply(func, x): # higher order function
    return func(x)

def square(n): # function to be passed
    return n * n

print(apply(square, 5))

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.

# higher order function returing a function
def fun(n):
    return lambda x: x * n

# creating mutiliplier functions 
double = fun(2)
triple = fun(3)

print(double(5))  
print(triple(5))  

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.

# Squaring each element in a list

a = [1, 2, 3, 4]
res = list(map(lambda x: x ** 2,a))
print(res)

[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.

# filtering even numbers

a = [1, 2, 3, 4, 5, 6]
res = list(filter(lambda x: x % 2 == 0, a))
print(res)

[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.

# sorting words based on length
a = ["python", "java", "javascript"]

res = sorted(a, key=len)
print(res)

['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:

def counter(start=0):  # higher order function
    count = start 
    
    def increment():  # inner function
        nonlocal count  # retains access to 'count' even after counter() ends
        count += 1
        return count
    
    return increment  # returns the inner function

counter1 = counter(5)  # closure retains count = 5
print(counter1())  
print(counter1())  

counter2 = counter(10)  # new closure with count = 10
print(counter2()) 

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:

# defining a decorator 
def decor(func):  
    
    # wrapper function 
    def wrap():  
        print("Before function execution")  
        func()  # calling the original function  
        print("After function execution")  
    return wrap  
  
# function to be decorated  
def func():  
    print("Inside the function!")  
  
# applying the decorator  
func = decor(func)  
  
# calling the decorated function  
func()

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().