Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/higher-order-functions-in-python/ below:

Higher Order Functions in Python

Last Updated : 12 Jul, 2025

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

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

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

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.

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

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.

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

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)

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

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)

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

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.

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.

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

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.

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4