When coding in Python, you might encounter a scenario where you need to filter a list using multiple conditions. The filter() function, combined with a lambda function, can accomplish this in a concise and readable way.
💡 Problem Formulation: Let’s say we have a list of integers, and we want to filter out numbers that are both even and greater than 10. Our input is a list of integers [1, 12, 17, 24, 29, 32], and our desired output is [12, 24, 32].
Method 1: Using filter with lambda and and
Using the filter() function with a lambda allows us to apply multiple conditions within a single lambda expression by leveraging the logical and. It’s readable and straightforward.
numbers = [1, 12, 17, 24, 29, 32] filtered_numbers = list(filter(lambda x: (x % 2 == 0) and (x > 10), numbers)) print(filtered_numbers)
This code creates a list of numbers that are filtered to include only even numbers greater than 10. The lambda function checks each number x for the two conditions before including them in the output list.
👉 How to Filter in Python using Lambda Functions?
Method 2: Using list comprehension
List comprehensions can replicate the functionality of filter() and lambda by incorporating the conditional logic directly. They are a popular Pythonic way to write concise and efficient code.
numbers = [1, 12, 17, 24, 29, 32] filtered_numbers = [x for x in numbers if (x % 2 == 0) and (x > 10)] print(filtered_numbers)
In this example, the list comprehension iterates through the list ‘numbers‘, applying the conditions to each element x and creating a new list with the elements that satisfy both conditions.
Method 3: Using a for loop
A for loop allows for more verbose but sometimes easier-to-read code when filtering with multiple conditions, especially for those less familiar with lambda functions or list comprehensions.
numbers = [1, 12, 17, 24, 29, 32]
filtered_numbers = []
for x in numbers:
if (x % 2 == 0) and (x > 10):
filtered_numbers.append(x)
print(filtered_numbers)This code block iterates over each number in the list using a for loop. It applies the conditional checks explicitly and appends those that meet the conditions to the result list.
Method 4: Using itertools.filterfalse
The itertools.filterfalse() function is the opposite of filter(), giving us items for which the predicate is false. To use it with multiple conditions, we combine conditions using or to filter out items that don’t meet our criteria.
from itertools import filterfalse numbers = [1, 12, 17, 24, 29, 32] filtered_numbers = list(filterfalse(lambda x: (x % 2 != 0) or (x <= 10), numbers)) print(filtered_numbers)
We are using filterfalse() to discard numbers that are not even (x % 2 != 0) or not greater than 10 (x <= 10). The remaining numbers satisfy the original conditions.
Method 5: Using a custom function
A custom function can replace the lambda for more complexity and readability. It’s useful when conditions are too complex for a one-liner.
numbers = [1, 12, 17, 24, 29, 32]
def is_even_and_gt_ten(x):
return (x % 2 == 0) and (x > 10)
filtered_numbers = list(filter(is_even_and_gt_ten, numbers))
print(filtered_numbers)The custom function is_even_and_gt_ten encapsulates the conditions. We then pass this function to filter(), which calls it for each element in the list.
Bonus One-Liner Method 6: Using reduce
While less commonly used for filtering, Python’s functools.reduce() can be adapted to filter elements. This is a more advanced and less conventional approach.
from functools import reduce numbers = [1, 12, 17, 24, 29, 32] filtered_numbers = reduce(lambda acc, x: acc + [x] if (x % 2 == 0) and (x > 10) else acc, numbers, []) print(filtered_numbers)
This one-liner uses reduce() to accumulate values that satisfy our conditions. The lambda function takes an accumulator acc and element x, appending x when it meets the conditions.
Summary/Discussion
In summary, there are several methods to filter a list in Python by multiple conditions.
Choosing between filter() with lambda, list comprehensions, for loops, itertools, custom functions, or even reduce(), depends on personal preference, readability, and the complexity of conditions.
List comprehensions and filter() with lambda are often the most readable and Pythonic choices, while custom functions are better for complex logic.
Use the bonus reduce() method with caution, as it can be less intuitive but is powerful for those comfortable with functional programming techniques.