Remove elements from a List while iterating in Python

# Table of Contents

1. Remove elements from a List while iterating in Python
2. Remove items from a List while iterating using a list comprehension
3. Remove items from a List while iterating using filter()
4. Removing items from a List while iterating over it with range()
5. Removing items from a list while iterating with filterfalse()

# Remove elements from a List while iterating in Python

To remove list elements while iterating over it:

1. Use a for loop to iterate over a copy of the list.
2. Check if each item meets a condition.
3. Use the list.remove() method to remove the items that meet the condition.

Copied!
my_list = [22, 33, 66, 77, 99]

for item in my_list.copy():
    if item < 50:
        my_list.remove(item)

print(my_list)  # 👉️ [66, 77, 99]

We used the list.copy() method to get a copy of the list.

Copied!
my_list = [22, 33, 66, 77, 99]

print(my_list.copy())  # 👉️ [22, 33, 66, 77, 99]

The list.copy() method returns a shallow copy of the object on which the method was called.

However, we can iterate over a copy of the list and remove items from the original list.

Copied!
my_list = [22, 33, 66, 77, 99]

for item in my_list.copy():
    if item < 50:
        my_list.remove(item)

print(my_list)  # 👉️ [66, 77, 99]

On each iteration in the for loop, we check if the current item is less than 50 and remove the elements that meet the condition.

# Using list slicing to get a shallow copy

You might also see examples that use the my_list[:] syntax to get a shallow copy of the list by using list slicing.

Copied!
my_list = [22, 33, 66, 77, 99]

for item in my_list[:]:
    if item < 50:
        my_list.remove(item)

print(my_list)  # 👉️ [66, 77, 99]

We used the my_list[:] syntax to get a slice that represents the entire list.

Copied!
my_list = [22, 33, 66, 77, 99]

print(my_list[:])  # 👉️ [22, 33, 66, 77, 99]

In general, the list.copy() method is a little more readable than using a slice that represents the entire list.

Here is another example.

Copied!
my_list = [None, 22, 33, None, 66, 77, None, 99]


for item in my_list.copy():
    if item is None:
        my_list.remove(item)

print(my_list)  # 👉️ [22, 33, 66, 77, 99]

We used a for loop to remove all None values from a list while iterating over it.

The most important thing to note when removing items from a list in a for loop is to use the list.copy() method to iterate over a copy of the list.

If you try to iterate over the original list and remove items from it, you might run into difficult-to-locate bugs.

# You don't have to create a copy if you aren't changing the list's length

If you aren't removing or adding new items to the list when iterating over it, you don't have to create a copy.

Copied!
my_list = [5, 11, 25, 7, 30]

for index, item in enumerate(my_list):
    if item <= 10:
        my_list[index] = 10

print(my_list)  # 👉️ [10, 11, 25, 10, 30]

We used the enumerate() function to get access to the index of the current iteration.

The enumerate() function takes an iterable and returns an enumerate object containing tuples where the first element is the index and the second is the item.

The example checks if the current list item is less than or equal to 10 and if the condition is met, the item gets set to 10.

# Remove items from a List while iterating using a list comprehension

Alternatively, you can use a list comprehension.

The list comprehension will return a new list containing only the elements that match the condition.

Copied!
my_list = [77, 105, 123, 88, 199]

new_list = [item for item in my_list if item > 100]

print(new_list)  # 👉️ [105, 123, 199]

We used a list comprehension to remove the items from a list while iterating.

On each iteration, we check if the current item is greater than 100 and return the result.

The new list will only contain values that are greater than 100.

The list comprehension in the example doesn't mutate the original list.

# Removing the items from the original list with a list comprehension

If you need to mutate the original list, assign the result to a slice that represents the entire list.

You can update the list in place by using a slice assignment.

Copied!
my_list = [77, 105, 123, 88, 199]

my_list[:] = [item for item in my_list if item > 100]

print(my_list)  # 👉️ [105, 123, 199]

We used the my_list[:] syntax to get a slice that represents the entire list, so we can assign to the variable directly.

Copied!
my_list = [77, 105, 123, 88, 199]

print(my_list[:]) # 👉️ [77, 105, 123, 88, 199]

The slice my_list[:] represents the entire list, so when we use it on the left-hand side, we are assigning to the entire list.

This approach changes the contents of the original list.

# Remove items from a List while iterating using filter()

You can also use the filter() function to remove items from a list while iterating.

Copied!
my_list = [77, 105, 123, 88, 199]

new_list = list(filter(
    lambda x: x > 100,
    my_list
))

print(new_list) # 👉️ [105, 123, 199]

The filter() function takes a function and an iterable as arguments and constructs an iterator from the elements of the iterable for which the function returns a truthy value.

The lambda function we passed to filter gets called with each element of the list.

On each iteration, we check if the current item is greater than 100 and return the result.

The filter object only contains the elements for which the condition is met.

The last step is to convert the filter object to a list using the list() class.

# Removing items from a List while iterating over it with range()

You can also use the range() class to remove items from a list while iterating over it.

Copied!
my_list = [77, 105, 123, 88, 199, 4, 1, 5]

for index in range(len(my_list) - 1, -1, -1):
    print(index)
    if my_list[index] < 100:
        my_list.pop(index)

# 👇️ [105, 123, 199]
print(my_list)

The range() class is commonly used for looping a specific number of times in for loops and takes the following arguments:

We used a negative step to reverse the range.

Copied!
my_list = [77, 105, 123, 88, 199, 4, 1, 5]


# 👇️ [7, 6, 5, 4, 3, 2, 1, 0]
print(list(range(len(my_list) - 1, -1, -1)))

The range object is not dependent on the list in any way, so removing items from the list doesn't influence the number of iterations.

# Removing items from a list while iterating with filterfalse()

You can also use the filterfalse method from the itertools module to remove items from the list while iterating over it.

Copied!
from itertools import filterfalse

my_list = [77, 105, 123, 88, 199, 4, 1, 5]


def check_func(num):
    return num < 100


my_list[:] = filterfalse(check_func, my_list)

print(my_list) # 👉️ [105, 123, 199]

Make sure to import the filterfalse method as shown in the code sample.

The filterfalse method takes a predicate and an iterable and calls the function with each item in the iterable.

The method returns a list containing the items for which the function returned false.

In the example, the method returns a list containing the items that are not less than 100.

Which approach you pick is a matter of personal preference. I'd use a for loop with list.copy() because I find it quite direct and intuitive.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• For or While loop to print Numbers from 1 to 10 in Python
• Using multiple variables in a For loop in Python
• Using a For or While Loop to take user input in Python