# 5 Best Ways to Separate Even and Odd Numbers in Python Lists

Rate this post

💡 Problem Formulation: Often in programming, you might need to categorize elements of a list into separate groups based on certain criteria. In this case, we want to take a list of integers as input and partition it into two distinct lists: one containing all the even numbers from the original list and the other comprising all the odd numbers. For example, given the input list `[2, 7, 5, 6, 4]`, the output should be two lists: `[2, 6, 4]` (even numbers) and `[7, 5]` (odd numbers).

## Method 1: Using loops

This method is straightforward and involves iterating through each element of the input list and checking if it is even or odd using the modulus operator. This way, we can append even numbers to one list and odd numbers to another. It’s a clear and easily understandable method.

Here’s an example:

```input_list = [2, 7, 5, 6, 4]
even_numbers = []
odd_numbers = []

for number in input_list:
if number % 2 == 0:
even_numbers.append(number)
else:
odd_numbers.append(number)
```

Output:

```Even numbers list: [2, 6, 4]
Odd numbers list: [7, 5]```

This code snippet uses a for-loop to go through each number in `input_list`. It checks if the number is even by using the modulus operator (number % 2). If the remainder is zero, it’s even, and the number is appended to `even_numbers`; otherwise, it’s appended to `odd_numbers`.

## Method 2: List comprehensions

List comprehensions in Python provide a concise way to create lists. This method uses two list comprehensions: one to filter even numbers and another for odd numbers, leveraging the same modulus operator as the loop method but in a more compact form.

Here’s an example:

```input_list = [2, 7, 5, 6, 4]
even_numbers = [number for number in input_list if number % 2 == 0]
odd_numbers = [number for number in input_list if number % 2 != 0]
```

Output:

```Even numbers list: [2, 6, 4]
Odd numbers list: [7, 5]```

In this example, list comprehensions are used to create `even_numbers` and `odd_numbers` by checking the condition inside the brackets. It’s similar to the loop method but more concise and potentially faster.

## Method 3: Using filter and lambda functions

This method makes use of Python’s higher-order functions—specifically, the `filter()` function, combined with lambda functions to elegantly separate the even and odd numbers into two lists. This approach is more functional in nature.

Here’s an example:

```input_list = [2, 7, 5, 6, 4]
even_numbers = list(filter(lambda x: x % 2 == 0, input_list))
odd_numbers = list(filter(lambda x: x % 2 != 0, input_list))
```

Output:

```Even numbers list: [2, 6, 4]
Odd numbers list: [7, 5]```

The `filter()` function applies a lambda function as a condition to each element in `input_list`, creating an iterator that is then converted into a list containing only numbers that satisfy the condition.

## Method 4: Using NumPy

For those dealing with numerical computations, NumPy is an indispensable library. The following method employs NumPy array operations to find even and odd numbers using boolean indexing—a powerful feature of NumPy that enables complex array operations to be executed in a clean and efficient manner.

Here’s an example:

```import numpy as np

input_array = np.array([2, 7, 5, 6, 4])
even_numbers = input_array[input_array % 2 == 0]
odd_numbers = input_array[input_array % 2 != 0]
```

Output:

```Even numbers array: [2 6 4]
Odd numbers array: [7 5]```

This snippet uses NumPy’s boolean indexing to specify a condition directly on the array, resulting in a more performant solution especially for large datasets. Note that the result is a NumPy array, not a regular Python list.

## Bonus One-Liner Method 5: Using partition with a generator expression

For the Pythonistas who love one-liners, this method takes advantage of tuple unpacking and a generator expression to separate the evens and odds in a single line of code—a sleek trick for simple scripts or the Python console.

Here’s an example:

```input_list = [2, 7, 5, 6, 4]
even_numbers, odd_numbers = zip(*((number, ) if number % 2 == 0 else (, number) for number in input_list))
```

Output:

```Even numbers tuple: (2, 6, 4)
Odd numbers tuple: (7, 5)```

While this one-liner can be cryptic at first glance, it efficiently partitions the numbers into separate tuples based on their parity. It uses a generator to create pairs and then `zip()` with tuple unpacking to separate them. This method returns tuples, not lists.

## Summary/Discussion

• Method 1: Using loops. Simple to understand and implement. Can be slow for very large lists.
• Method 2: List comprehensions. Clean and Pythonic. More memory-intensive as it creates intermediate structures.
• Method 3: Using filter and lambda functions. Elegant and functional programming approach. Readability may be lower for those unfamiliar with lambda expressions.
• Method 4: Using NumPy. Highly efficient for numerical computations and large datasets. Requires NumPy library and results are in array format, not lists.
• Method 5: Bonus One-Liner. Extremely concise. Reduces readability and outputs tuples instead of lists.