In Python, functions are first-class objects meaning they can be assigned to variables, passed as arguments and returned from other functions. This enables higher-order functions, decorators and lambda expressions. By passing a function as an argument, we can modify a function’s behavior dynamically without altering its implementation. For Example:

def process(func, text):  # applies a function to text  
    return func(text)  

def uppercase(text):  # converts text to uppercase  
    return text.upper()  

print(process(uppercase, "hello"))

HELLO

Explanation: process() applies a given function to text and uppercase() converts text to uppercase. Passing uppercase to process with "hello" results in "HELLO".

Higher Order Functions

A higher-order function takes or returns another function, enabling reusable and efficient code. It supports functional programming with features like callbacks, decorators, and utilities such as map(), filter(), and reduce().

Example 1 : Basic function passing

# higher-order function
def fun(func, number):
    return func(number)

# function to double a number
def double(x):
    return x * 2

print(fun(double, 5))

10

Explanation: fun() takes double() as an argument and applies it to 5, returning 10.

Example 2: Passing Built-in Functions

# function to apply an operation on a list
def fun(func, numbers):
    return [func(num) for num in numbers]

# using the built-in 'abs' function
a = [-1, -2, 3, -4]
print(fun(abs, a))

[1, 2, 3, 4]

Explanation: abs() is passed to fun(), which applies it to each element in the list, converting negative numbers to positive.

Lambda Functions

A lambda function in Python is a small, anonymous function with a single expression, defined using lambda. It’s often used in higher-order functions for quick, one-time operations.

Example: Lambda Function as an Argument

# function that applies an operation to a number
def fun(func, number):
    return func(number)

# passing a lambda function
print(fun(lambda x: x ** 2, 5))

25

Explanation: lambda x: x ** 2 is passed to fun(), which squares the input 5 to produce 25.

Wrapper Functions(Decorators)

A wrapper function (decorator) enhances another function's behavior without modifying it. It takes a function as an argument and calls it within the wrapper.

Example 1 : Simple decorator

# simple decorator example
def decorator_fun(original_fun):
    def wrapper_fun():
        print("Hello, this is before function execution")
        original_fun()
        print("This is after function execution")
    return wrapper_fun

@decorator_fun
def display():
    print("This is inside the function !!")

# calling the decorated function
display()

Hello, this is before function execution
This is inside the function !!
This is after function execution

Explanation: decorator_fun wraps the display() function, adding pre- and post-execution messages.

Example 2: Lambda Wrapper Function

def apply_lambda(func, value):
    return func(value)

square = lambda x: x ** 2
print("Square of 2 is:", apply_lambda(square, 2))

Square of 2 is: 4

Explanation: apply_lambda() function applies the lambda function lambda x: x ** 2 to 2, returning 4.

Built-in Functions using function arguments

Python provides built-in functions that take other functions as arguments .

Example 1 : map()

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

[2, 4, 6, 8]

Explanation: map() function applies lambda x: x * 2 to each element in a, doubling all values.

Example 2 : filter()

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

[2, 4]

Explanation: filter() selects even numbers from the list using lambda x: x % 2 == 0.

Example 3: reduce()

from functools import reduce
a = [1, 2, 3, 4]

res = reduce(lambda x, y: x + y, a)
print(res) 

10

Explanation: reduce() function applies lambda x, y: x + y cumulatively to elements in a, summing them to 10.