Skip to content
Tutorial Reference

How to Resolve Python "ValueError: list.remove(x): x not in list' and 'ValueError: 'x' is not in list"

Learn how to fix Python's ValueError when using list.remove() or list.index() on non-existent values, with safe methods like in checks and exception handling.

When working with Python lists, two common methods for interacting with elements based on their value are list.remove(value) and list.index(value). However, both methods raise a ValueError if the specified value is not found within the list. Specifically, you might see ValueError: list.remove(x): x not in list or ValueError: 'x' is not in list.

This guide explains why these errors occur and provides standard, robust ways to handle situations where the value might be absent.

Understanding the Error: Value Must Exist for remove() and index()

  • list.remove(value): Searches the list for the first occurrence of value and removes it. If value is not found in the list at all, it cannot perform the removal and raises a ValueError.
  • list.index(value): Searches the list for the first occurrence of value and returns its index. If value is not found, it cannot return an index and raises a ValueError.

Both methods require the value you're operating on to be present in the list.

Error 1: ValueError: list.remove(x): x not in list

Cause: Calling remove() with a Non-Existent Value

You tried to remove an item that isn't present in the list.

fruits = ['apple', 'banana', 'cherry']
item_to_remove = 'grape' # This item is not in the list

print(f"List: {fruits}")
print(f"Trying to remove: '{item_to_remove}'")

fruits.remove(item_to_remove)
print(f"List after removal: {fruits}")

The safest way to avoid the error is to first check if the item exists using the in operator before attempting to remove it.

fruits = ['apple', 'banana', 'cherry']
item_to_remove = 'grape'
item_present = 'banana'

print(f"List: {fruits}")

if item_to_remove in fruits:
    print(f"Removing '{item_to_remove}'...")
    fruits.remove(item_to_remove)
else:
    print(f"Can not remove: '{item_to_remove}' is not in the list.")

print(f"List after checking 'grape': {fruits}")     # Output: ['apple', 'banana', 'cherry']

if item_present in fruits:
    print(f"Removing '{item_present}'...")
    fruits.remove(item_present)
    print(f"List after removing 'banana': {fruits}") # Output: ['apple', 'cherry']
else:
     print(f"Can not remove: '{item_present}' is not in the list.")

Output:

List: ['apple', 'banana', 'cherry']
Can not remove: 'grape' is not in the list.
List after checking 'grape': ['apple', 'banana', 'cherry']
Removing 'banana'...
List after removing 'banana': ['apple', 'cherry']
  • if item_to_remove in fruits:: This membership test efficiently checks for the presence of the item without raising an error if it's missing.

Solution 2: Use try...except ValueError

You can attempt the removal directly and catch the ValueError if it occurs.

fruits = ['apple', 'banana', 'cherry']
item_to_remove = 'grape'

print(f"List: {fruits}")
print(f"Attempting to remove '{item_to_remove}' using try/except...")

try:
    fruits.remove(item_to_remove)
    print("Removal successful.") # This won't run
except ValueError:
    print(f"Caught ValueError: '{item_to_remove}' not found in list.")

print(f"List after try/except: {fruits}") # Output: ['apple', 'banana', 'cherry']

Output:

ERROR!
List: ['apple', 'banana', 'cherry']
Attempting to remove 'grape' using try/except...
Caught ValueError: 'grape' not found in list.
List after try/except: ['apple', 'banana', 'cherry']

This is useful if you expect the item usually to be present, or if you want to explicitly handle the "not found" case in the except block.

Removing Multiple Items Safely

If you need to remove multiple items, loop through the items-to-remove list and apply one of the safe methods (check with in or use try/except) for each item.

  • Do not modify the list you are directly iterating over without care.
  • iterating over the items_to_remove list is safe.
main_list = ['a', 'b', 'c', 'd', 'e', 'b']
items_to_remove = ['b', 'x', 'd'] # 'x' is not in main_list, 'b' appears twice

print(f"Original list: {main_list}")
print(f"Items to remove: {items_to_remove}")

for item in items_to_remove:
    print(f"Attempting to remove '{item}'...")
    try:
        main_list.remove(item) # Removes only the *first* 'b'
        print(f"  Removed '{item}'.")
    except ValueError:
        print(f"  '{item}' not found in list.")

print(f"Final list: {main_list}")

Output:

Original list: ['a', 'b', 'c', 'd', 'e', 'b']
Items to remove: ['b', 'x', 'd']
Attempting to remove 'b'...
  Removed 'b'.
Attempting to remove 'x'...
  'x' not found in list.
Attempting to remove 'd'...
  Removed 'd'.
Final list: ['a', 'c', 'e', 'b']

Alternative: Filtering with List Comprehension

If you want to create a new list excluding certain items (instead of modifying the original), a list comprehension is often cleaner and more efficient than repeated remove() calls.

main_list = ['a', 'b', 'c', 'd', 'e', 'b']
items_to_exclude = {'b', 'd'} # Use a set for faster lookups

filtered_list = [item for item in main_list if item not in items_to_exclude]

print(f"Original list: {main_list}")
print(f"Items to exclude: {items_to_exclude}")
print(f"Filtered list: {filtered_list}")

Output:

Original list: ['a', 'b', 'c', 'd', 'e', 'b']
Items to exclude: {'d', 'b'}
Filtered list: ['a', 'c', 'e']

Error 2: ValueError: 'X' is not in list (using index())

Cause: Calling index() with a Non-Existent Value

You tried to find the index of an item that isn't present in the list.

colors = ['red', 'green', 'blue']
search_value = 'yellow' # Not in the list

print(f"List: {colors}")
print(f"Trying to find index of: '{search_value}'")

try:
    idx = colors.index(search_value)
    print(f"Index found: {idx}")
except ValueError as e:
    print(e)

Output:

List: ['red', 'green', 'blue']
Trying to find index of: 'yellow'
'yellow' is not in list

Verify the item exists before calling .index().

colors = ['red', 'green', 'blue']
search_value = 'yellow'
value_present = 'green'

print(f"List: {colors}")

if search_value in colors:
    idx = colors.index(search_value)
    print(f"Index of '{search_value}': {idx}")
else:
    print(f"Cannot get index: '{search_value}' is not in the list.")

if value_present in colors:
    idx = colors.index(value_present)
    print(f"Index of '{value_present}': {idx}") # Output: 1
else:
     print(f"Cannot get index: '{value_present}' is not in the list.")

Output:

List: ['red', 'green', 'blue']
Cannot get index: 'yellow' is not in the list.
Index of 'green': 1

Solution 2: Use try...except ValueError

Attempt to get the index and handle the ValueError if the item isn't found.

colors = ['red', 'green', 'blue']
search_value = 'yellow'
index_result = -1 # Default value if not found

print(f"List: {colors}")
print(f"Attempting to find index of '{search_value}' using try/except...")

try:
    index_result = colors.index(search_value)
    print(f"Index found: {index_result}") # This won't run
except ValueError:
    print(f"Caught ValueError: '{search_value}' not found in list.") # This is executed

print(f"Final index result: {index_result}") # Output: -1

Output:

ERROR!
List: ['red', 'green', 'blue']
Attempting to find index of 'yellow' using try/except...
Caught ValueError: 'yellow' not found in list.
Final index result: -1

Important Notes:

Type Matching

Both remove() and index() perform comparisons based on value and type. my_list.remove(3) will not remove the string '3'. Ensure the value you pass matches the type of the elements in the list. Convert types (int(), str()) if necessary before calling the methods.

Example with Error:

numbers = [1, 2, 3, 4]
value_str = '3'

numbers.remove(value_str)

Correct Example:

numbers = [1, 2, 3, 4]
value_str = '3'

numbers.remove(int(value_str))
print(f"List after removing int(3): {numbers}")

Output:

List after removing int(3): [1, 2, 4]

Nested Lists

If working with lists of lists, ensure you call remove() or index() on the correct list (either the outer list or one of the inner lists).

nested_list = [['a', 'b'], ['c', 'd']]

inner_list = nested_list[0] # Get the inner list ['a', 'b']
inner_list.remove('b')
print(f"Nested list after removing 'b' from inner: {nested_list}")

inner_list_2 = nested_list[1]
idx = inner_list_2.index('c')
print(f"Index of 'c' in second inner list: {idx}")

Output:

Nested list after removing 'b' from inner: [['a'], ['c', 'd']]
Index of 'c' in second inner list: 0

Conclusion

The ValueError: list.remove(x): x not in list and ValueError: 'x' is not in list (from index()) both occur when the specified value x is not found within the Python list.

To prevent these errors:

  1. Check Before Acting (Recommended): Use the in operator (if value in my_list:) to verify the value exists before calling my_list.remove(value) or my_list.index(value).
  2. Use Exception Handling: Wrap the .remove(value) or .index(value) call in a try...except ValueError: block to gracefully handle cases where the value might be missing.
  3. Ensure Type Match: Verify that the type of the value passed to remove() or index() matches the type of the elements within the list. Convert if necessary.
  4. Consider Alternatives: For removing multiple items, list comprehensions ([item for item in my_list if item not in items_to_remove]) are often cleaner and more efficient.

Choosing the right approach depends on whether you need to handle the "not found" case explicitly or simply avoid the error. The if value in my_list: check is often the most readable and direct way to prevent the ValueError.

Navigation