How to Fix: ValueError: list.remove(x): x not in list

This is a common ValueError that occurs when you try to remove an item from a list, but that item isn’t in the list. The specific error is called ValueError list.remove when Python fails to find the value you want to remove.

The Cause

The .remove() method is strict. If it can’t find the exact item you asked to remove, it will crash.

# WRONG — 99 is not in the list, .remove() crashes
my_list = [10, 20, 30, 40]
my_list.remove(99)            # ValueError: list.remove(x): 99 not in list

# WRONG — case-sensitive mismatch: "alice" is not "Alice"
names = ["Alice", "Bob", "Charlie"]
names.remove("alice")         # ValueError: list.remove(x): alice not in list

# FIX 1 — in check before remove (LBYL — use when the missing item matters)
item = 99
if item in my_list:
    my_list.remove(item)
else:
    print(f"{item} not found.")

# FIX 2 — try/except (EAFP — use when missing item is expected and ignorable)
try:
    my_list.remove(99)
except ValueError:
    pass                      # silently skip — item already gone or never existed

# FIX 3 — list comprehension to remove ALL occurrences at once
my_list = [10, 20, 10, 30, 10]
my_list = [x for x in my_list if x != 10]   # removes every 10
print(my_list)                # Output: [20, 30]

Problem Code:

my_list = [10, 20, 30, 40]

# This works
my_list.remove(20) # my_list is now [10, 30, 40]

# This crashes!
my_list.remove(99)
# CRASH! ValueError: list.remove(x): 99 not in list

The Fix: Check First with in (LBYL)

The safest way to remove an item is to “Look Before You Leap.” Use the in keyword to check if the item exists before you try to remove it.

my_list = [10, 30, 40]
item_to_remove = 99

if item_to_remove in my_list:
    my_list.remove(item_to_remove)
else:
    print(f"{item_to_remove} was not in the list.")

This is the standard, safe way to handle removing items and avoids all crashes.

Alternative: try/except (EAFP)

You can also use a try/except block, which is sometimes cleaner if you don’t care about printing an error message.

try:
    my_list.remove(99)
except ValueError:
    pass # Do nothing, just ignore the error

ValueError: list.remove(x): x not in list — Three Removal Patterns and When Each Applies

ValueError: list.remove(x): x not in list enforces one contract: the item must exist in the list before .remove() touches it. Python searches left to right, finds the first match, removes it, and stops. No match — ValueError, no partial work, no silent skip.

Three patterns cover every real-world removal scenario.

Use in before .remove() when the item’s absence is meaningful. A task manager removing a completed task, a shopping cart removing a product, a user system removing a permission — if the missing item means something went wrong upstream, the in check lets you handle that case explicitly with a log, a message, or a fallback.

Use try/except ValueError when the item’s absence is expected and ignorable. A deduplication script, a cleanup routine, a retry loop — when “remove it if it’s there” is the complete intent and a missing item is a normal non-event, try/except removes the boilerplate of the in check and makes the intent clear.

Use a list comprehension when you need to remove all occurrences at once. .remove() deletes only the first match. [10, 20, 10, 30, 10].remove(10) produces [20, 10, 30, 10] — two 10s survive. A list comprehension [x for x in my_list if x != 10] removes every 10 in one pass. It creates a new list and leaves the original untouched — assign it back to the variable if you want the in-place effect.

The .discard() method worth knowing for sets: sets have no .remove()-equivalent that crashes — my_set.discard(99) removes 99 if present and silently does nothing if absent. If your collection only needs unique items and removal order doesn’t matter, switch to a set and use .discard(). No guard code, no exception handling, no ValueError.