Higher-Order Functions and Function Arguments | CodeSignal Learn

Higher-Order Functions and Function Arguments | CodeSignal Learn

Lesson Introduction

In modern programming, higher-order functions, which are functions that take other functions as arguments, are fundamental tools. They make your programs more flexible, reusable, and modular. Our goal for this lesson is to learn how to implement a function that takes another function as an argument. This concept is crucial for custom algorithms and many standard library functions. Ready to dive in? Let's start!

The Advantages of Using Functions as Arguments

Before we delve into the main topic, let's quickly recap how Python treats functions as first-class objects. This means that functions can be passed around and used as arguments just like any other object (string, int, float, list, etc.). First-Class Objects : In Python, functions are first-class objects. This means they can be assigned to variables, passed as arguments, and returned from other functions. Lambda Functions : These are small, anonymous functions defined using the lambda keyword. They can have any number of arguments but only one expression. The expression is evaluated and returned. Why pass functions as arguments? Imagine working on a list of integers and needing to filter out certain elements. You can create a generic function that takes another function (the filter criterion) to handle the filtering. This avoids code duplication and makes your logic clear and concise.

Example Problem: Filter Elements from a List

Let's see this in action by filtering elements from a list. We will implement a filter_list function that takes a list and another boolean function, which defines the filtering rules. Python # Function that takes another function to filter list elements def filter_list(lst, filter_func): filtered_list = [elem for elem in lst if filter_func(elem)] print("Filtered Elements:", filtered_list) Let's break down the implementation: Function Definition : Python def filter_list(lst, filter_func): This specifies that filter_list takes a list of integers and a function that returns a boolean. List Comprehension : Python filtered_list = [elem for elem in lst if filter_func(elem)] This creates a new list containing only the elements that satisfy filter_func . Printing the Filtered Elements : Python print("Filtered Elements:", filtered_list)

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Example Problem: Using the Function

Let's look at an example of using the function implemented previously. In this case, we will use a list of numbers, but our general filter_list function can work with any data type. def main(): numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Filter even numbers is_even = lambda n: n % 2 == 0 filter_list(numbers, is_even) # Output: Filtered Elements: [2, 4, 6, 8, 10] # Filter numbers greater than 5 greater_than_five = lambda n: n > 5 filter_list(numbers, greater_than_five) # Output: Filtered Elements: [6, 7, 8, 9, 10] if __name__ == "__main__": main() In this main function: We create a list, numbers, with integers from 1 to 10. We define the is_even lambda to identify even numbers. This will be our boolean function that defines the filtering rules. We call filter_list with is_even to filter and print even numbers. We define another lambda, greater_than_five, to filter and print numbers greater than 5.

Handling Different Scenarios

Functions that take other functions as arguments are highly flexible. You can easily swap out the function argument to handle different scenarios. Here are more examples: Filtering odd numbers: is_odd = lambda n: n % 2 != 0 filter_list(numbers, is_odd) # Output: Filtered Elements: [1, 3, 5, 7, 9] Filtering numbers within a range: within_range = lambda n: 3 < n < 8 filter_list(numbers, within_range) # Output: Filtered Elements: [4, 5, 6, 7] Each example shows adapting filter_list to different needs by changing the function passed as an argument.

Python

def main():
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    # Filter even numbers
    is_even = lambda n: n % 2 == 0
    filter_list(numbers, is_even)
    # Output: Filtered Elements: [2, 4, 6, 8, 10]

    # Filter numbers greater than 5
    greater_than_five = lambda n: n > 5
    filter_list(numbers, greater_than_five)
    # Output: Filtered Elements: [6, 7, 8, 9, 10]

if __name__ == "__main__":
    main()