Higher-Order Functions in Python: Concepts, Examples and Uses

First-Class Functions in Python

First, let’s understand what first-class functions are and how they are used in higher-order functions.

Definition: First-class functions are functions that Python treats like values. You can assign them to variables, pass them as arguments, return them from other functions, and store them in collections.

Think of a function like a piece of information that can be stored, passed around or returned whenever needed. Python allows functions to be handled in these ways just like other values.

Let’s understand how Python treats functions as values through the following scenarios:

1. Treating Functions Like Values
2. Assigning a Function to a Variable
3. Storing Functions in Collections
4. Passing Functions as Arguments
5. Returning Functions From Functions

1. Treating Functions Like Values

When you use a function name without parentheses, Python refers to the function itself rather than calling it.

def greet():
    print("Hello")

print(greet)


# Output:
<function greet at 0x...>

Explanation: Here, greet refers to the function itself. Python does not run the function because there are no parentheses after greet.

↑ Move to Section Top

2. Assigning a Function to a Variable

You can assign a function to a variable just as you assign other values to a variable.

def greet():
    print("Hello")

message = greet

message()


# Output:
Hello

Explanation: Here, message refers to the same function as greet. Calling message() runs the greet() function.

Note: Notice that greet is assigned without parentheses. Writing greet() would call the function instead of assigning the function itself.

↑ Move to Section Top

3. Storing Functions in Collections

Since functions can be treated like values, you can also store them in collections such as lists.

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

operations = [add, multiply]

print(operations[0](5, 3))
print(operations[1](5, 3))


# Output:
8
15

Explanation: Here, the list stores the add and multiply functions. The functions are not called when they are added to the list.

The functions are called later using their positions in the list. operations[0](5, 3) calls add(), while operations[1](5, 3) calls multiply().

↑ Move to Section Top

4. Passing Functions as Arguments

Python allows you to pass a function to another function as an argument. This is useful when a function needs to use another function to perform a task.

1. Passing a Function Without Calling It
2. Calling the Received Function
3. Building a Function That Accepts Another Function

1. Passing a Function Without Calling It

When you pass a function as an argument, write the function name without parentheses.

def greet():
    print("Hello")

def process(func):
    print(func)

process(greet)

Explanation: Here, greet refers to the function itself, so process() receives the function as an argument. Python does not call greet() when you pass it this way.

If you write process(greet()), Python calls greet() first and passes its return value to process() instead.

2. Calling the Received Function

A function received as an argument can be called inside the receiving function.

def greet():
    return "Hello"

def process(func):
    return func()

result = process(greet)

print(result)


# Output:
Hello

Explanation: Here, process() receives greet through the func parameter. The expression func() calls the received function.

3. Building a Function That Accepts Another Function

You can build a function that accepts another function and uses it to process a value.

def double(number):
    return number * 2

def apply_operation(value, operation):
    return operation(value)

result = apply_operation(5, double)

print(result)


# Output:
10

Explanation: Here, apply_operation() receives double as the operation argument and calls it with value. The function can therefore use the function passed to it.

You can pass a different function to apply_operation() without changing its code.

def triple(number):
    return number * 3

result = apply_operation(5, triple)

print(result)


# Output:
15

Explanation: Here, apply_operation() works with triple instead of double. The receiving function stays the same while the function passed to it changes.

↑ Move to Section Top

5. Returning Functions From Functions

A function can return another function instead of returning its result. This allows the returned function to be stored and used later.

1. Returning and Calling a Function
2. Creating Functions Dynamically

1. Returning and Calling a Function

A function can return another function by using the function name with the return statement.

def greet():
    return "Hello"

def get_function():
    return greet

message = get_function()

print(message())


# Output:
Hello

Explanation: Here, get_function() returns the greet function. The returned function is stored in message, and message() calls it.

Note: Notice that return greet does not use parentheses. Writing return greet() would call the function and return its result instead.

2. Creating Functions Dynamically

A function can create another function inside its body and return it. This allows the outer function to create different functions based on the values passed to it.

def create_multiplier(number):
    def multiply(value):
        return value * number

    return multiply

double = create_multiplier(2)
triple = create_multiplier(3)

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


# Output:
10
15

Explanation: Here, create_multiplier() creates a multiply() function using the value passed to number. It returns that function, which is stored in double and triple.

The two returned functions use different values. double(5) multiplies by 2, while triple(5) multiplies by 3.

↑ Move to Section Top