The Python standard library provides the filter() function as a tool for processing iterables. Similar to map(), this function accepts two arguments: a function that defines the filtering logic and an iterable to be processed. However, unlike map(), which transforms elements, filter() evaluates each element against the provided function. If the function returns True, the element is retained in the output; if it returns False, the element is discarded.

Basic Filtering Operations

Consider a scenario where you need to isolate odd integers from a mixed list. You can define a validation function and pass it to filter():

def check_if_odd(number):
    return number % 2 != 0

data_set = [10, 15, 22, 33, 40, 55]
odd_numbers = list(filter(check_if_odd, data_set))
# Result: [15, 33, 55]

Another common use case is cleaning up a list by removing empty strings or null values. The following example keeps only strings that contain non-whitespace characters:

def is_valid_string(text):
    # Returns True for non-empty strings after stripping whitespace
    return bool(text) and text.strip()

raw_data = ["apple", "", "banana", None, "   ", "cherry"]
cleaned_data = list(filter(is_valid_string, raw_data))
# Result: ['apple', 'banana', 'cherry']

The effectiveness of filter() relies on passing a predicate function that accurately reflects the selection criteria. Its important to note that filter() returns an iterator in Python 3. This means the computation is lazy; elements are processed one by one only when requested. To view all results at once, you must explicitly convert the iterator to a list or iterate through it in a loop.

Advanced Example: Generating Prime Numbers

We can utilize filter() to implement the Sieve of Eratosthenes, an efficient algorithm for finding prime numbers. The algorithm begins by listing natural numbers starting from 2. It identifies the first number as prime, then filters out all multiples of that number from the remaining sequence. This process repeats with the next number in the filtered sequence.

To implement this, we first need an infinite generator that produces odd numbers starting from 3:

def generate_odd_numbers():
    n = 1
    while True:
        n += 2
        yield n

Next, we define a factory function that returns a filter lambda. This lambda checks if a candidate number is divisible by a given prime:

def get_filter_func(divisor):
    return lambda x: x % divisor > 0

Finally, we construct the prime number generator. It yields 2 (the only even prime), then iteratively applies filters to the sequence of odd numbers to remove multiples of identified primes:

def create_prime_stream():
    yield 2
    sequence = generate_odd_numbers()
    while True:
        prime = next(sequence)
        yield prime
        # Create a new iterator that filters out multiples of the current prime
        sequence = filter(get_filter_func(prime), sequence)

Since create_prime_stream() generates an infinite sequence of primes, you must handle the iteration carefully to avoid an infinite loop:

# Print prime numbers less than 100
for prime in create_prime_stream():
    if prime < 100:
        print(prime)
    else:
        break