# Remove all occurrences of a value from a list?

In Python `remove()` will remove the first occurrence of value in a list.

How to remove all occurrences of a value from a list?

This is what I have in mind:

``````>>> remove_values_from_list([1, 2, 3, 4, 2, 2, 3], 2)
[1, 3, 4, 3]
``````

Functional approach:

Python 3.x

``````>>> x = [1,2,3,2,2,2,3,4]
>>> list(filter((2).__ne__, x))
[1, 3, 3, 4]
``````

or

``````>>> x = [1,2,3,2,2,2,3,4]
>>> list(filter(lambda a: a != 2, x))
[1, 3, 3, 4]
``````

Python 2.x

``````>>> x = [1,2,3,2,2,2,3,4]
>>> filter(lambda a: a != 2, x)
[1, 3, 3, 4]
``````
• Use the list comprehension over the filter+lambda; the former is more readable in addition to generally more efficient. – habnabit Jul 21 '09 at 4:28
• s/generally/generally being/ – habnabit Jul 21 '09 at 4:29
• The code for habnabit's suggestion looks like this: `[y for y in x if y != 2]` – coredumperror Apr 22 '13 at 22:12
• I wouldn't call this solution the best. List comprehensions are faster and easier to understand while skimming through code. This would rather be more of a Perl way than Python. – Peter Nimroot Aug 13 '16 at 15:25
• -1 for directly invoking `__ne__`. Comparing two values is a far more complex process than just calling `__eq__` or `__ne__` on one of them. It may work correctly here because you're only comparing numbers, but in the general case that's incorrect and a bug. – Aran-Fey Jun 4 '18 at 7:11

You can use a list comprehension:

``````def remove_values_from_list(the_list, val):
return [value for value in the_list if value != val]

x = [1, 2, 3, 4, 2, 2, 3]
x = remove_values_from_list(x, 2)
print x
# [1, 3, 4, 3]
``````
• How would you remove items without checking them? – Alexander Ljungberg Jul 21 '09 at 3:20
• This doesn't modify the original list but returns a new list. – John Y Jul 21 '09 at 3:20
• @Selinap: No, this is optimal as it scans the list only once. In your original code both the `in` operator and `remove` method scan the entire list (up until they find a match) so you end up scanning the list multiple times that way. – John Kugelman Jul 21 '09 at 3:24
• @mhawke, @John Y: just use x[:] = ... instead of x = and it will be "in-place" rather than just rebinding the name 'x' (speed is essentially the same and MUCH faster than x.remove can be!!!). – Alex Martelli Jul 21 '09 at 3:33
• I vote this up because after 6 years of Python I still don't understand Lambdas :) – neydroydrec Sep 29 '12 at 10:47

You can use slice assignment if the original list must be modified, while still using an efficient list comprehension (or generator expression).

``````>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> x[:] = (value for value in x if value != 2)
>>> x
[1, 3, 4, 3]
``````
• @Selinap: filter does not modify the list, it returns a new list. – E.M. Jul 21 '09 at 3:47
• filter and list comprehensions don't modify a list. slice assignment does. and the original example does. – A. Coady Jul 22 '09 at 23:24
• I like this because it modifies the list that x refers to. If there are any other references to that list, they will be affected too. This is in contrast to the `x = [ v for v in x if x != 2 ]` proposals, that create a new list and change x to refer to it, leaving the original list untouched. – Hannes Sep 7 '16 at 5:06

Repeating the solution of the first post in a more abstract way:

``````>>> x = [1, 2, 3, 4, 2, 2, 3]
>>> while 2 in x: x.remove(2)
>>> x
[1, 3, 4, 3]
``````
• It's O(n*n), though. – Hannes Sep 7 '16 at 4:45
• @Hannes would not it be O(n) since it is going through the loop just once & at the same time removing the item ? – penta Mar 28 '19 at 4:01
• Consider `x =  * 10000 +  * 1000`. The loop body executes 1000 times and .remove() has to skip 10000 elements every time it's invoked. That smells like O(n*n) to me but is no proof. I think the proof would be to assume that the number of 2s in the list is proportional to its length. That proportionality factor then disappears in big-O notation. The best case, though, of only a constant number of 2s in the list, is not O(n^2), just O(2n) which is O(n). – Hannes Apr 2 '19 at 6:13

See the simple solution

``````>>> [i for i in x if i != 2]
``````

This will return a list having all elements of `x` without `2`

• if the list is a very long story, it could take a minute to finish because it loops through all the items. – Milad shiri Oct 10 '20 at 7:56

All of the answers above (apart from Martin Andersson's) create a new list without the desired items, rather than removing the items from the original list.

``````>>> import random, timeit
>>> a = list(range(5)) * 1000
>>> random.shuffle(a)

>>> b = a
>>> print(b is a)
True

>>> b = [x for x in b if x != 0]
>>> print(b is a)
False
>>> b.count(0)
0
>>> a.count(0)
1000

>>> b = a
>>> b = filter(lambda a: a != 2, x)
>>> print(b is a)
False
``````

This can be important if you have other references to the list hanging around.

To modify the list in place, use a method like this

``````>>> def removeall_inplace(x, l):
...     for _ in xrange(l.count(x)):
...         l.remove(x)
...
>>> removeall_inplace(0, b)
>>> b is a
True
>>> a.count(0)
0
``````

As far as speed is concerned, results on my laptop are (all on a 5000 entry list with 1000 entries removed)

• List comprehension - ~400us
• Filter - ~900us
• .remove() loop - 50ms

So the .remove loop is about 100x slower........ Hmmm, maybe a different approach is needed. The fastest I've found is using the list comprehension, but then replace the contents of the original list.

``````>>> def removeall_replace(x, l):
....    t = [y for y in l if y != x]
....    del l[:]
....    l.extend(t)
``````
• removeall_replace() - 450us
• Why not just reassign the new list under the old address then? `def remove_all(x, l): return [y for y in l if y != x]` then `l = remove_all(3,l)` – Dannid Mar 1 '16 at 17:58
• @Dannid That's the second method in the first code box. It creates a new list, and you're not modifying the old list. Any other references to the list will remain unfiltered. – Paul S Mar 10 '16 at 17:25
• Ah, right. I got so caught up in defining a method, I overlooked the simple assignment you'd already done. – Dannid Mar 14 '16 at 21:19

better solution with list comprehension

``````x = [ i for i in x if i!=2 ]
``````
• That's a bad solution, since the list has to be traversed 2*n times for n occurrences of 2. – cxxl Nov 25 '16 at 14:55
• It is not recommended to add or remove from the list you are traversing. Bad practice IMHO. – Aman Mathur Apr 22 '17 at 5:51

Numpy approach and timings against a list/array with 1.000.000 elements:

Timings:

``````In : a.shape
Out: (1000000,)

In : len(lst)
Out: 1000000

In : %timeit a[a != 2]
100 loops, best of 3: 2.94 ms per loop

In : %timeit [x for x in lst if x != 2]
10 loops, best of 3: 79.7 ms per loop
``````

Conclusion: numpy is 27 times faster (on my notebook) compared to list comprehension approach

PS if you want to convert your regular Python list `lst` to numpy array:

``````arr = np.array(lst)
``````

Setup:

``````import numpy as np
a = np.random.randint(0, 1000, 10**6)

In : a.shape
Out: (1000000,)

In : lst = a.tolist()

In : len(lst)
Out: 1000000
``````

Check:

``````In : a[a != 2].shape
Out: (998949,)

In : len([x for x in lst if x != 2])
Out: 998949
``````

At the cost of readability, I think this version is slightly faster as it doesn't force the while to reexamine the list, thus doing exactly the same work remove has to do anyway:

``````x = [1, 2, 3, 4, 2, 2, 3]
def remove_values_from_list(the_list, val):
for i in range(the_list.count(val)):
the_list.remove(val)

remove_values_from_list(x, 2)

print(x)
``````
• For the list you show in your code, this approach is about 36% slower than the list comprehension method (which returns a copy), according to my measurement. – djsmith Oct 14 '12 at 3:55
• Good you noticed that. However, because I think it might have slipped your judgement, I was comparing my version with the very first proposal made by the question author. – Martin Andersson Oct 15 '12 at 8:01
``````a = [1, 2, 2, 3, 1]
to_remove = 1
a = [i for i in a if i != to_remove]
print(a)
``````

Perhaps not the most pythonic but still the easiest for me haha

To remove all duplicate occurrences and leave one in the list:

``````test = [1, 1, 2, 3]

newlist = list(set(test))

print newlist

[1, 2, 3]
``````

Here is the function I've used for Project Euler:

``````def removeOccurrences(e):
return list(set(e))
``````
• I needed to do this on a vector with 250k values, and it works like a charm. – rschwieb Mar 1 '13 at 0:13
• The answer is: yes! And I completely understand if having a vector that long sounds completely crazy to a competent programmer. I approach the problems there as a mathematician, not worrying about optimizing the solutions, and that can lead to solutions longer than the par. (Although I don't have any patience for solutions longer than 5 minutes.) – rschwieb Mar 1 '13 at 14:08
• This will remove any ordering from the list. – asmeurer Jul 16 '13 at 22:03
• @JaredBurrows perhaps because it doesn't answer the question as it currently stands, but a quite different question. – drevicko Jun 15 '14 at 11:47
• -1, this is not an answer to the OP's question. It is a solution to remove duplicates, which is a completely different matter. – Anoyz Jul 22 '16 at 11:18

I believe this is probably faster than any other way if you don't care about the lists order, if you do take care about the final order store the indexes from the original and resort by that.

``````category_ids.sort()
ones_last_index = category_ids.count('1')
del category_ids[0:ones_last_index]
``````
• I understand where your'e going, but this code won't work since you need also the start index and not just 0. – Shedokan Apr 27 '13 at 10:31
``````for i in range(a.count(' ')):
a.remove(' ')
``````

Much simpler I believe.

Let

``````>>> x = [1, 2, 3, 4, 2, 2, 3]
``````

The simplest and efficient solution as already posted before is

``````>>> x[:] = [v for v in x if v != 2]
>>> x
[1, 3, 4, 3]
``````

Another possibility which should use less memory but be slower is

``````>>> for i in range(len(x) - 1, -1, -1):
if x[i] == 2:
x.pop(i)  # takes time ~ len(x) - i
>>> x
[1, 3, 4, 3]
``````

Timing results for lists of length 1000 and 100000 with 10% matching entries: 0.16 vs 0.25 ms, and 23 vs 123 ms. ### Remove all occurrences of a value from a Python list

``````lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list():
for list in lists:
if(list!=7):
print(list)
remove_values_from_list()
``````

Result: `6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11`

### Alternatively,

``````lists = [6.9,7,8.9,3,5,4.9,1,2.9,7,9,12.9,10.9,11,7]
def remove_values_from_list(remove):
for list in lists:
if(list!=remove):
print(list)
remove_values_from_list(7)
``````

Result: `6.9 8.9 3 5 4.9 1 2.9 9 12.9 10.9 11`

• "Python 'nested for each if loop' within a function working with 100% accuracy!" – rafiqul786 Apr 1 '16 at 7:05
• You don't modify the list you just print the elements. Also naming a list as lists is confusing – kon psych May 31 '16 at 4:48

If you didn't have built-in `filter` or didn't want to use extra space and you need a linear solution...

``````def remove_all(A, v):
k = 0
n = len(A)
for i in range(n):
if A[i] !=  v:
A[k] = A[i]
k += 1

A = A[:k]
``````
``````hello =  ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
#chech every item for a match
for item in range(len(hello)-1):
if hello[item] == ' ':
#if there is a match, rebuild the list with the list before the item + the list after the item
hello = hello[:item] + hello [item + 1:]
print hello
``````

['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

I just did this for a list. I am just a beginner. A slightly more advanced programmer can surely write a function like this.

``````for i in range(len(spam)):
spam.remove('cat')
if 'cat' not in spam:
print('All instances of ' + 'cat ' + 'have been removed')
break
``````

We can also do in-place remove all using either `del` or `pop`:

``````import random

def remove_values_from_list(lst, target):
if type(lst) != list:
return lst

i = 0
while i < len(lst):
if lst[i] == target:
lst.pop(i)  # length decreased by 1 already
else:
i += 1

return lst

remove_values_from_list(None, 2)
remove_values_from_list([], 2)
remove_values_from_list([1, 2, 3, 4, 2, 2, 3], 2)
lst = remove_values_from_list([random.randrange(0, 10) for x in range(1000000)], 2)
print(len(lst))

``````

Now for the efficiency:

``````In : %timeit -n1 -r1 x = random.randrange(0,10)
1 loop, best of 1: 43.5 us per loop

In : %timeit -n1 -r1 lst = [random.randrange(0, 10) for x in range(1000000)]
g1 loop, best of 1: 660 ms per loop

In : %timeit -n1 -r1 lst = remove_values_from_list([random.randrange(0, 10) for x in range(1000000)]
...: , random.randrange(0,10))
1 loop, best of 1: 11.5 s per loop

In : %timeit -n1 -r1 x = random.randrange(0,10); lst = [a for a in [random.randrange(0, 10) for x in
...:  range(1000000)] if x != a]
1 loop, best of 1: 710 ms per loop

``````

As we see that in-place version `remove_values_from_list()` does not require any extra memory, but it does take so much more time to run:

• 11 seconds for inplace remove values
• 710 milli seconds for list comprehensions, which allocates a new list in memory

No one has posted an optimal answer for time and space complexity, so I thought I would give it a shot. Here is a solution that removes all occurrences of a specific value without creating a new array and at an efficient time complexity. The drawback is that the elements do not maintain order.

Time complexity: O(n)

``````def main():
test_case([1, 2, 3, 4, 2, 2, 3], 2)     # [1, 3, 3, 4]
test_case([3, 3, 3], 3)                 # []
test_case([1, 1, 1], 3)                 # [1, 1, 1]

def test_case(test_val, remove_val):
remove_element_in_place(test_val, remove_val)
print(test_val)

def remove_element_in_place(my_list, remove_value):
length_my_list = len(my_list)
swap_idx = length_my_list - 1

for idx in range(length_my_list - 1, -1, -1):
if my_list[idx] == remove_value:
my_list[idx], my_list[swap_idx] = my_list[swap_idx], my_list[idx]
swap_idx -= 1

for pop_idx in range(length_my_list - swap_idx - 1):
my_list.pop() # O(1) operation

if __name__ == '__main__':
main()
``````

``````import time
s_time = time.time()

print 'start'
a = range(100000000)
del a[:]
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 3.25

s_time = time.time()
print 'start'
a = range(100000000)
a = []
print 'finished in %0.2f' % (time.time() - s_time)
# start
# finished in 2.11
``````
``````p=[2,3,4,4,4]
p.clear()
print(p)
[]
``````

Only with Python 3

• Hilariously, this is within the scope of the question asked and is correct. – Erich Aug 28 '17 at 22:26
• I don't see how it is correct. This will remove all items from the list, not all occurrences of a value. – Georgy Feb 19 '20 at 15:10

What's wrong with:

``````Motor=['1','2','2']
For i in Motor:
If i  != '2':
Print(i)
Print(motor)
``````

Using anaconda

• Please explain your lines of code so other users can understand its functionality. Thanks! – Ignacio Ara Apr 25 '18 at 9:19
{"ft_lang_label":"__label__en","ft_lang_prob":0.6459412,"math_prob":0.9548529,"size":9809,"snap":"2021-21-2021-25","text_gpt3_token_len":3312,"char_repetition_ratio":0.13278939,"word_repetition_ratio":0.08998302,"special_character_ratio":0.3953512,"punctuation_ratio":0.21434529,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.980836,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,7,null,7,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-05-10T20:13:56Z\",\"WARC-Record-ID\":\"<urn:uuid:b654de00-a6c1-4ae9-aba1-235cefa1e41d>\",\"Content-Length\":\"379504\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:f15fb645-2e3d-4d29-8c9c-b0bba549f371>\",\"WARC-Concurrent-To\":\"<urn:uuid:177bc915-31b4-4daf-ac28-b8e33dfbf190>\",\"WARC-IP-Address\":\"151.101.1.69\",\"WARC-Target-URI\":\"https://stackoverflow.com/questions/1157106/remove-all-occurrences-of-a-value-from-a-list/1157160\",\"WARC-Payload-Digest\":\"sha1:L7CPUR4YGSPO2FA574XTYMSK4SOVCR33\",\"WARC-Block-Digest\":\"sha1:PIJN2BHS3D7SXDWPAOLOKWKOY6LYZBCI\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-21/CC-MAIN-2021-21_segments_1620243991759.1_warc_CC-MAIN-20210510174005-20210510204005-00459.warc.gz\"}"}