5 Best Ways to Extract Even Numbers from a List in Python

by

💡 Problem Formulation: In Python programming, it’s a common task to filter out even numbers from a list. This operation involves inspecting each element in the list and determining if it is divisible by 2 without a remainder. Given an input list such as [1, 2, 3, 4, 5, 6], we aim to extract the even numbers and obtain an output like [2, 4, 6].

Method 1: Using a For Loop

This is the most direct method where each element of the list is checked using a for loop and if the element is an even number (i.e., divisible by 2), it is printed. This method is simple and easy to understand for beginners.

Here’s an example:

num_list = [1, 2, 3, 4, 5, 6]
for num in num_list:
    if num % 2 == 0:
        print(num)

Output:

2
4
6

The code iterates over the list using a for loop, and for each number, it checks whether the number is even using the modulo operator (%). If the remainder of the division by 2 is 0, the number is even, and it is printed.

Method 2: Using List Comprehension

List comprehension offers a more concise way to generate lists in Python. To print the even numbers, we can create a new list that only contains the even elements of the original list and then print the elements of the new list.

Here’s an example:

num_list = [1, 2, 3, 4, 5, 6]
even_numbers = [num for num in num_list if num % 2 == 0]
print(even_numbers)

Output:

[2, 4, 6]

In this snippet, a new list called even_numbers is created with a list comprehension that includes a conditional expression to filter out only even elements. The resulting list is then printed.

Method 3: Using the filter() Function

The filter() function is used to create an iterator from elements of an iterable for which a function returns true. In this case, we can use a lambda function to check for even numbers, and then convert the iterator to a list for printing.

Here’s an example:

num_list = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda num: num % 2 == 0, num_list))
print(even_numbers)

Output:

[2, 4, 6]

The code uses the filter() function with a lambda that returns true only for even numbers. The filter() function applies the lambda to each element in num_list and the result is cast to a list before printing.

Method 4: Using numpy

NumPy is a popular library in Python for numerical computations. It can be used to efficiently filter even numbers from a list (or more precisely, a NumPy array) using Boolean indexing.

Here’s an example:

import numpy as np

num_array = np.array([1, 2, 3, 4, 5, 6])
even_numbers = num_array[num_array % 2 == 0]
print(even_numbers)

Output:

[2 4 6]

In this code, we first create a NumPy array from the list. Then, we use a Boolean condition (num_array % 2 == 0) to index the array, which filters out only the even elements. Lastly, the even numbers are printed.

Bonus One-Liner Method 5: Using a Generator Expression

Generator expressions are similar to list comprehensions but more memory-efficient because they do not require the creation of a list in memory. Instead, they generate values one by one, which is perfect when you just need to iterate and print them.

Here’s an example:

num_list = [1, 2, 3, 4, 5, 6]
for num in (num for num in num_list if num % 2 == 0):
    print(num)

Output:

2
4
6

The code uses a generator expression within a for loop to print each even number from the original list. No intermediary list is created, making it efficient for large lists.

Summary/Discussion

  • Method 1: Using a For Loop. Strengths – Easy for beginners to understand. Weaknesses – Verbosity, not the most Pythonic way.
  • Method 2: Using List Comprehension. Strengths – Concise and readable. Weaknesses – Requires the creation of an intermediate list, which might be memory-inefficient for large lists.
  • Method 3: Using the filter() Function. Strengths – Functional programming approach, clear intent. Weaknesses – Less beginner-friendly, requires conversion back to list for printing.
  • Method 4: Using numpy. Strengths – Efficient for large datasets and multi-dimensional arrays, concise syntax. Weaknesses – Requires NumPy installation, overkill for small or simple use cases.
  • Method 5: Bonus One-Liner Using a Generator Expression. Strengths – Memory-efficient. Weaknesses – Might be less intuitive for those unfamiliar with generators.