Python Filter List: 5 Practical Methods Explained

by | Python

An important aspect of data analysis is to get the right data. You need a mechanism to find and extract relevant data. Lists are one of the frequently used data structures and Python offers multiple ways of filtering a list to get relevant data.

In Python, you can filter lists using the built-in `filter()` function, list comprehensions, or ‘for’ loops combined with conditional statements. The `filter()` function applies a specific function to a list and returns an iterable for the elements where the function returned True, list comprehensions provide a concise syntax for creating new lists based on existing ones, and ‘for’ loops can also be used with ‘if’ statements to iterate over a list.

Python Filter List

If you’re a beginner, you’ll find yourself confused about choosing the right filter method for your use case. This blog will help you understand 5 ways of filtering a list in Python. Furthermore, you’ll gain knowledge on when to use what method.

Let’s get into it!

5 Ways to Filter Python List

In this section, we’ll talk about 5 ways of filtering a list in Python.

We’ll go over the following:

  1. Filtering with built-in filter function
  2. Filtering with list comprehension
  3. Filtering with loops and conditional statements
  4. Filtering with NumPy library
  5. Filtering with Pandas library

1. Filtering With Built-in Filter() Function

Python comes loaded with a range of functions to help make programming more efficient. As you utilize filtering methods in your code, you’ll find that in most cases, the built-in filter() function will be your go-to method for filtering.

The filter() is a built-in Python function that allows you to process an iterable (like a list or tuple) and extract elements that satisfy a specific condition.

The syntax for the filter() function is as follows:

filter(function, iterable)

The function inside filter() is a custom function that tests each element in the iterable to determine if it satisfies the given condition. If the function returns True for an element, it’s included in the output.

The following example shows how to filter elements with the filter() function:

def is_even(x):
    return x % 2 == 0

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = filter(is_even, my_list)
new_list = list(result)

In this example, the built-in filter() function applies the is_even() function to the list elements. The filter() function returns an iterator, which is then converted to a new list containing only the even numbers. The even elements are kept, whereas the odd elements are filtered out.

The filtered list is shown below:

Filtering with Built-In Filter Function

You can also use lambda functions with the filter() function to create more concise and readable code.

The following example demonstrates using lambda expressions with filter() function:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

result = filter(lambda x: x % 2 == 0, my_list)
new_list = list(result)


In this example, the lambda expression replaces the is_even() function.

Using filter with lambda function

The lambda function returns true if the number is even, else it returns false.

When to Use the Built-in Filter() Function

The built-in filter() function takes two arguments: a function and a list.

The filter() function is useful when you have an existing function that you want to apply to a sequence. It’s often used in functional programming styles.

2. Filtering With List Comprehension

List comprehension allows you to build lists based on existing lists or iterable objects. It allows you to perform operations such as filter in a single line of code.

Suppose we have a list of numbers and we want to create a new list containing the squares of only the even numbers. We can use a list comprehension to achieve this:

numbers = [1, 2, 3, 4, 5, 6]
even_squares = [x ** 2 for x in numbers if x % 2 == 0]

In this example, the expression x ** 2 calculates the square of each element x in numbers. The if condition filters out only even elements, and the final list comprehension returns a new list containing the squares of those even values.

Filtering with List Comprehension

When to Use List Comprehension

This is a Pythonic way of creating lists based on existing lists. It’s useful when the logic can be implemented in a single line. It’s often recommended when you want concise, readable code and the filtering logic is not overly complicated.

3. Filtering With Loops and Conditional Statements

You can also filter a list with loops and conditional statements, but this is generally not preferred in large-scale projects.

To filter a list, we iterate through its elements and apply a specific criterion to each element. If the criterion is met (returns True), the element is added to the output list; otherwise, it’s excluded (returns False).

The following example demonstrates this method:

input_list = [1, 2, 3, 4, 5, 6]
output_list = []

for number in input_list:
    if number % 2 == 0:

print(output_list)  # Output: [2, 4, 6]

In this example, we use a for loop to iterate through the elements in input_list. Inside the loop, we use an if statement to check if the number is even by using the modulus operator (%). If the condition evaluates to True, the number is appended to the output_list.

Filtering with Loops and Conditional Statements

When to Use Loops and Conditional Statements

This is a basic way to filter a list and does not require any additional Python knowledge beyond loops and conditions. It’s easy to understand and can be used in any situation, but it may lead to more verbose code compared to other methods. If you use multiple if-else conditions, your code easily becomes unreadable.

4. Filtering With NumPy Library

NumPy is used for numerical computations and has support for arrays. You can filter arrays in NumPy using boolean indexing.

An example of filtering with NumPy is given below:

import numpy as np

list_1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = np.array(list_1)
evens = numbers[numbers % 2 == 0]


In this example, we perform the operation numbers % 2 == 0. This operation is applied to every element in the numbers array which results in a boolean array.

We use this boolean array to index the original numbers array, which effectively filters out the even numbers.

Filtering with NumPy Library

When to Use NumPy Library

This is useful when you’re dealing with numerical data and you need to perform operations on multi-dimensional arrays. NumPy has powerful and efficient array filtering capabilities, especially for larger datasets. If you are working on numerical computations and performance is a concern, NumPy can be a good choice.

5. Filtering With Pandas Library

Pandas is widely used for data manipulation and analysis. The filtering of a Pandas Series is similar to the filtering of a NumPy array, but instead of the array, we’re working with a Series object.

The following example demonstrates filtering a list with Pandas library:

import pandas as pd

numbers = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9])
evens = numbers[numbers % 2 == 0]


In this example, we perform the operation numbers % 2 == 0. This operation is applied to every element in the numbers Series resulting in a boolean series.

We use this boolean Series to index the original numbers Series, which filters out the even numbers.

 Filtering with Pandas Library

When to Use Pandas Library

Pandas is great for data manipulation and analysis. It’s especially useful when you are dealing with structured data like CSV, Excel files, or SQL databases.

If your data is more complex than simple lists or your filtering logic involves complex operations like group by, merge, join, etc., then pandas would be the go-to choice.

Final Thoughts

Filtering is a fundamental operation. Whether you’re handling small data lists or enormous datasets, the ability to filter and extract meaningful information is essential.

Learning these techniques not only broadens your skill set but also prepares you for the varied and often unpredictable nature of real-world programming tasks.

Understanding when and how to use different filtering methods — built-in functions, list comprehension, loops, NumPy, or Pandas — enables you to write more efficient and readable code. Happy coding!

To learn more about how to use Python, check out the playlist below:

Frequently Asked Questions

How do I filter a list of objects in Python?

You can filter object by using the built-in filter() function. The filter() function accepts two arguments: a filtering function and an iterable (e.g., a list). The filtering function should return either True or False for each element in the iterable.

In the example below, the filter() function returns a new iterable containing only those elements that satisfy the filtering function.

my_objects = [obj1, obj2, obj3, obj4]

def filtering_function(obj):
    return obj.attribute > threshold

filtered_objects = filter(filtering_function, my_objects)

What is the best way to filter a list of strings in Python?

There are multiple ways to filter a list of strings in Python, including using filter() or list comprehensions. The method you choose depends on your specific requirements and coding style preferences.

Here’s an example of list comprehension:

string_list = ["apple", "banana", "cherry", "kiwi"]
filtered_list = [x for x in string_list if "a" in x]

How can I use Lambda to filter a Python list?

You can use the lambda function to create an anonymous filtering function for the filter() function.

For example, if you want to filter a list of integers to include only even numbers, you can use the following one-liner:

int_list = [1, 2, 3, 4, 5, 6]
filtered_list = list(filter(lambda x: x % 2 == 0, int_list))

How do I use list comprehensions to filter lists in Python?

List comprehensions offer a more concise way to filter lists in Python. They consist of an expression followed by a for statement and an optional if statement, all within square brackets.

The following example filters a list of numbers to keep only the positive ones:

numbers = [-3, -2, -1, 0, 1, 2, 3]
positive_numbers = [num for num in numbers if num > 0]

What is the method to filter a list of dictionaries in Python?

To filter a list of dictionaries, you can use list comprehensions or the filter() function.

Here’s an example using list comprehension to filter a list of dictionaries based on the value of a specific key:

dict_list = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"},
    {"id": 3, "name": "Charlie"},

filtered_list = [item for item in dict_list if item["id"] > 1]

How do I filter a Python array?

Python arrays can be filtered in the same way as lists, using either the filter() function or list comprehensions.

For example, you can filter a NumPy array as follows:

import numpy as np

array = np.array([1, 2, 3, 4, 5])
filtered_array = array[array > 3]

In this example, the array is filtered using boolean indexing to keep only the elements greater than 3.

author avatar
Sam McKay, CFA
Sam is Enterprise DNA's CEO & Founder. He helps individuals and organizations develop data driven cultures and create enterprise value by delivering business intelligence training and education.

Related Posts