filter() function is a built-in Python function used to filter elements from an iterable (like a list or tuple) based on a specific condition or criteria. It processes each item in the iterable and returns only those that satisfy the condition.
The syntax of filter( ) is:
- function: A function that tests if each item of the iterable meets a certain condition. The function should return
Falsefor each element.
- iterable: The iterable (e.g., list, tuple, set) whose elements you want to filter.
filter() Return Value
filter() function returns an iterator containing elements for which the function returns
Consider you have a list of numbers and you want to retain only the even numbers:
def is_even(num): return num % 2 == 0 numbers = [1, 2, 3, 4, 5] even_numbers = filter(is_even, numbers) print(list(even_numbers)) # Outputs: [2, 4]
In this example, the
is_even function checks if a number is even. We use this function as the test function for
filter(), which then processes the
numbers list and retains only the even numbers.
It’s also common to use lambda functions with
filter() for shorter, throwaway functions:
numbers = [1, 2, 3, 4, 5] even_numbers = filter(lambda x: x % 2 == 0, numbers) print(list(even_numbers)) # Outputs: [2, 4]
In essence, the
filter() function provides a convenient way to selectively process elements from an iterable based on a specified condition.
Filtering Out Empty Strings
Consider you have a list of strings, and you want to remove any empty strings:
strings = ["apple", "", "banana", "cherry", ""] result = filter(lambda s: s != "", strings) print(list(result)) # Outputs: ["apple", "banana", "cherry"]
Removing Outliers in Data
For a list of data points, you can filter out values that lie outside a specific range:
data = [10, 45, 60, 85, 150, 200] filtered_data = filter(lambda x: 50 <= x <= 150, data) print(list(filtered_data)) # Outputs: [60, 85, 150]
filter( ) with Lambda Functions
filter(), we often need a function to determine whether each item in an iterable should be included in the output. For simple filtering criteria, it can be overkill to define a separate function using
def. Instead, we can use a lambda function directly within
Example: Filtering Strings by Length
Imagine you have a list of words, and you only want to keep words with more than 3 characters:
words = ["apple", "pie", "and", "sky", "hi"] long_words = filter(lambda word: len(word) > 3, words) print(list(long_words)) # Outputs: ['apple']
Why Use Lambda with filter( ) ?
- Conciseness: Lambda functions provide a concise way to define simple functions. This makes the code shorter and often more readable.
- Throwaway Use: Lambda functions are anonymous, meaning they don’t have a name. This is beneficial for “throwaway” or one-time use functions, which are only needed temporarily and won’t be reused elsewhere in the code.
- Functional Style: Combining
filter()with lambda functions promotes a functional programming style, emphasizing operations on data collections without side effects.
Using lambda functions with
filter() provides a streamlined way to filter items from iterables. The combination allows for concise, clear, and efficient filtering of data without the need for verbose function definitions, especially for simple filtering conditions.
filter() function is a powerful and versatile tool in Python that aids in processing sequences. Whether you’re cleaning data, transforming sequences, or performing various tasks that require conditional processing of iterables,
filter() is an indispensable tool.