Table of Contents

filter()

Rumman Ansari August 08, 2026 28 views Subject Details

CHAPTER 29.6 · ADVANCED PYTHON FEATURES

filter() in Python

Learn how to select values from Python iterables using conditions, named functions, lambda expressions, and truth-value testing.

Python programs frequently need to select only those values that satisfy a particular condition. For example, a program may need even numbers, active employees, valid records, positive values, or words longer than a specified length.

The built-in filter() function applies a test function to every item in an iterable. It keeps the items for which the function returns a truthy result.

Learning objective: Learn how to use filter() with named functions, lambda expressions, strings, dictionaries, and None.

Prerequisites

What You Should Know

Python lists, tuples, strings, and dictionaries
Writing and calling functions
Boolean expressions and comparison operators
Using if conditions
Basic knowledge of lambda expressions
Basic understanding of iterables and iterators

What is filter()?

filter() is a built-in Python function that selects items from an iterable according to a test function.

If the function returns a truthy result, the item is retained. If it returns a falsy result, the item is excluded.

Think of filter() as a selection gate

Every item passes through a condition. Matching items continue to the result, while nonmatching items are rejected.

Syntax

FILTER SYNTAX

filter(function, iterable)

filter(function, iterable)

Argument	Purpose
`function`	Tests every item and returns a truthy or falsy result.
`iterable`	Supplies the values to be tested.

Filter Even Numbers

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


numbers = [
    1,
    2,
    3,
    4,
    5,
    6
]

even_numbers = filter(
    is_even,
    numbers
)

print(list(even_numbers))

Output:

[2, 4, 6]

The is_even() function returns True for even numbers, so only those numbers remain.

What Does filter() Return?

numbers = [1, 2, 3]

result = filter(
    lambda number: number > 1,
    numbers
)

print(type(result))

Output:

<class 'filter'>

filter() returns a filter object. Convert it with list() when a list is required.

Use filter() with lambda

Select numbers greater than 10:

numbers = [
    5,
    12,
    7,
    20,
    3,
    18
]

selected_numbers = list(
    filter(
        lambda number: number > 10,
        numbers
    )
)

print(selected_numbers)

Output:

[12, 20, 18]

Use lambda for short conditions. Use a named function when the filtering logic is complex or reusable.

Filter String Values

Select words containing more than five characters:

words = [
    "Python",
    "Code",
    "Developer",
    "List",
    "Function"
]

long_words = list(
    filter(
        lambda word: len(word) > 5,
        words
    )
)

print(long_words)

Output:

['Python', 'Developer', 'Function']

Filter by Starting Letter

names = [
    "Amina",
    "Rahul",
    "Anita",
    "David",
    "Arif"
]

names_starting_with_a = list(
    filter(
        lambda name: name.startswith("A"),
        names
    )
)

print(names_starting_with_a)

Output:

['Amina', 'Anita', 'Arif']

Use filter() with None

Passing None as the function removes values that evaluate as false.

values = [
    "Python",
    "",
    None,
    "Java",
    0,
    False,
    "C#"
]

truthy_values = list(
    filter(
        None,
        values
    )
)

print(truthy_values)

Output:

['Python', 'Java', 'C#']

Important filter(None, values) removes every falsy value, including zero, empty strings, None, and False. Do not use it when zero is valid data.

Filter Dictionary Records

employees = [
    {
        "name": "Amina",
        "active": True
    },
    {
        "name": "Rahul",
        "active": False
    },
    {
        "name": "David",
        "active": True
    }
]

active_employees = list(
    filter(
        lambda employee:
            employee["active"],
        employees
    )
)

for employee in active_employees:
    print(employee["name"])

Output:

Amina
David

Use Multiple Conditions

numbers = range(1, 31)

selected_numbers = list(
    filter(
        lambda number:
            number % 2 == 0
            and number % 3 == 0,
        numbers
    )
)

print(selected_numbers)

Output:

[6, 12, 18, 24, 30]

filter Object Exhaustion

numbers = [
    1,
    2,
    3,
    4
]

even_numbers = filter(
    lambda number: number % 2 == 0,
    numbers
)

print(list(even_numbers))
print(list(even_numbers))

Output:

[2, 4]
[]

The first conversion consumes the filter object. Create a new filter object when another pass is required.

filter() vs List Comprehension

Using filter()

even_numbers = list(
    filter(
        is_even,
        numbers
    )
)

Using List Comprehension

even_numbers = [
    number
    for number in numbers
    if number % 2 == 0
]

Prefer filter()

An existing test function is available
The result will be consumed during iteration
Falsy values must be removed with None

Prefer List Comprehension

The condition is easier to read inline
Filtering and transformation are both required
A list is immediately required

Combine filter() and map()

First filter even numbers, and then calculate their squares:

numbers = [
    1,
    2,
    3,
    4,
    5,
    6
]

even_numbers = filter(
    lambda number: number % 2 == 0,
    numbers
)

even_squares = map(
    lambda number: number ** 2,
    even_numbers
)

print(list(even_squares))

Output:

[4, 16, 36]

Practical Example: Eligible Orders

orders = [
    {
        "order_number": "ORD-101",
        "amount": 750,
        "completed": True
    },
    {
        "order_number": "ORD-102",
        "amount": 1500,
        "completed": True
    },
    {
        "order_number": "ORD-103",
        "amount": 1800,
        "completed": False
    }
]

def is_eligible(order):
    return (
        order["completed"]
        and order["amount"] >= 1000
    )


eligible_orders = list(
    filter(
        is_eligible,
        orders
    )
)

for order in eligible_orders:
    print(order["order_number"])

Output:

ORD-102

Common Mistakes

Calling the Function

Incorrect filter(is_even(), numbers)

Correct filter(is_even, numbers)

Expecting a List

filter() returns a filter object.

Solution Convert it using list() when necessary.

Transforming Instead of Testing

The filter function should test whether an item should remain.

Solution Use map() or list comprehension when values must be transformed.

Removing Valid Zero Values

filter(None, values) removes zero because it is falsy.

Solution Use an explicit condition when zero must be retained.

Best Practices

Recommended Practices

Pass the test function without calling it.
Use named functions for reusable conditions.
Use lambda only for short conditions.
Return a clear truthy or falsy result.
Use explicit conditions when zero is valid data.
Remember that filter objects are consumed.
Prefer comprehension when it is easier to understand.

Knowledge Check

What does filter() return?

It returns a filter object containing the items that satisfy the supplied test.

How do you create a list from filter()?

result = list(
    filter(
        function,
        iterable
    )
)

What happens when the function is None?

Items that evaluate as falsy are removed.

filter() Quick Reference

# Use a named function
result = filter(
    function,
    iterable
)

# Convert to a list
result = list(
    filter(
        function,
        iterable
    )
)

# Use lambda
result = list(
    filter(
        lambda item: condition,
        iterable
    )
)

# Remove falsy values
result = list(
    filter(
        None,
        iterable
    )
)

# Iterate directly
for item in filter(
    function,
    iterable
):
    print(item)

Summary

What You Learned

filter() selects items from an iterable.
The test function determines whether an item is retained.
It returns a filter object rather than a list.
Named functions and lambda expressions can be used.
Passing None removes falsy values.
A filter object is consumed during iteration.
List comprehension may be clearer for inline conditions.

Key Takeaway

Use filter() when an iterable must retain only the values that satisfy a clear condition. Use named functions for complex tests, lambda for short tests, and list comprehension when it improves readability.