I'm iterating over a list of tuples in Python, and am attempting to remove them if they meet certain criteria.

for tup in somelist:
    if determine(tup):
         code_to_remove_tup

What should I use in place of code_to_remove_tup? I can't figure out how to remove the item in this fashion.

18 Answers 11

You need to take a copy of the list and iterate over it first, or the iteration will fail with what may be unexpected results.

For example (depends on what type of list):

for tup in somelist[:]:
    etc....

An example:

>>> somelist = range(10)
>>> for x in somelist:
...     somelist.remove(x)
>>> somelist
[1, 3, 5, 7, 9]

>>> somelist = range(10)
>>> for x in somelist[:]:
...     somelist.remove(x)
>>> somelist
[]
9 upvote
  flag
Zen #3, Simple is better than complex. Gets my vote! – jdero
4 upvote
  flag
why the second one works? – Zen
7 upvote
  flag
@Zen Because the second one iterates over a copy of the list. So when you modify the original list, you do not modify the copy that you iterate over. – Lennart Regebro
upvote
  flag
@LennartRegebro, oh my god, that's a genius idea, that list copy will automatically disappeared after for loop executed? – Zen
upvote
  flag
@Zen it will get garbage collected, yes. – Lennart Regebro
upvote
  flag
Correct me if I'm wrong but as this is not using the index but rather whatever's actually stored in the list to do the remove, it won't work for more complex items such as dicts, etc. – fantabolous
1 upvote
  flag
@fantabolous: Dicts doesn't have an index, so it wouldn't work anyway. – Lennart Regebro
upvote
  flag
@LennartRegebro, I meant lists of dicts, but actually after testing it looks like I was wrong anyway - sorry. – fantabolous
2 upvote
  flag
What's better in doing somelist[:] compared to list(somelist) ? – Mariusz Jamro
2 upvote
  flag
list(somelist) will convert an iterable into a list. somelist[:] makes a copy of an object that supports slicing. So they don't necessarily do the same thing. In this case I want to make a copy of the somelistobject, so I use [:] – Lennart Regebro
16 upvote
  flag
Note to anyone reading this, this is VERY slow for lists. remove() has to go over the WHOLE list for every iteration, so it will take forever. – vitiral
1 upvote
  flag
This is the method mentioned in the official tutorial: //allinonescript.com/a/34238688/895245 – Ciro Santilli 华涌低端人口 六四事件 法轮功
2 upvote
  flag
@navin and twice the memory! – vitiral
upvote
  flag
it's nice to know the alter syntax, given it's given in documentation also. But please also mention in your answer it's more time and memory consuming. – User
upvote
  flag
Big O time doesn't matter when dealing with lists of only a dozen items. Often clear and simple for future programmers to understand is far more valuable than performance. – Steve
upvote
  flag
@Lennart Regebro : Amazing answer with example. thanks!! – Sunny Chaudhari

Your best approach for such an example would be a list comprehension

somelist = [tup for tup in somelist if determine(tup)]

In cases where you're doing something more complex than calling a determine function, I prefer constructing a new list and simply appending to it as I go. For example

newlist = []
for tup in somelist:
    # lots of code here, possibly setting things up for calling determine
    if determine(tup):
        newlist.append(tup)
somelist = newlist

Copying the list using remove might make your code look a little cleaner, as described in one of the answers below. You should definitely not do this for extremely large lists, since this involves first copying the entire list, and also performing an O(n) remove operation for each element being removed, making this an O(n^2) algorithm.

for tup in somelist[:]:
    # lots of code here, possibly setting things up for calling determine
    if determine(tup):
        newlist.append(tup)
up vote 507 down vote accepted

You can use a list comprehension to create a new list containing only the elements you don't want to remove:

somelist = [x for x in somelist if not determine(x)]

Or, by assigning to the slice somelist[:], you can mutate the existing list to contain only the items you want:

somelist[:] = [x for x in somelist if not determine(x)]

This approach could be useful if there are other references to somelist that need to reflect the changes.

Instead of a comprehension, you could also use itertools. In Python 2:

from itertools import ifilterfalse
somelist[:] = ifilterfalse(determine, somelist)

Or in Python 3:

from itertools import filterfalse
somelist[:] = filterfalse(determine, somelist)
3 upvote
  flag
Can you make it faster if you know only a few will be deleted, i.e., only delete those and leave the others in-place rather than re-writing them? – highBandWidth
3 upvote
  flag
What if my list is huge and can't afford making a copy? – jpcgt
4 upvote
  flag
@jpcgt You should use somelist[:] = (x for x in somelist if determine(x)) this will create generator that may not create any unnecessary copies. – Rostislav Kondratenko
6 upvote
  flag
@RostislavKondratenko: list_ass_slice() function that implements somelist[:]= calls PySequence_Fast() internally. This function always returns a list i.e., @Alex Martelli's solution that already uses a list instead of a generator is most probably more efficient – jfs
upvote
  flag
It doesn't work for duplicate items in the list. – CrazyGeek
upvote
  flag
These are very hard to read. – Terra Ashley
1 upvote
  flag
@CrazyGeek: What do you mean doesn't work? – Moberg
for i in xrange(len(somelist) - 1, -1, -1):
    if some_condition(somelist, i):
        del somelist[i]

You need to go backwards otherwise it's a bit like sawing off the tree-branch that you are sitting on :-)

9 upvote
  flag
In recent versions of Python, you can do this even more cleanly by using the reversed() builtin – ncoghlan
upvote
  flag
Just a note that in python 2 you can do for i,v in enumerate(reversed(somelist)):, but to get at the indices you need to store the original lenght. The index of element v is originalLength - i - 1. – drevicko
upvote
  flag
@ncoghlan don't use reversed, that creates an entirely new list for no reason. If you want to do it that way, use itertools.islice(somelist, None, None, -1) (not tested, but should work) – vitiral
12 upvote
  flag
reversed() does not create a new list, it creates a reverse iterator over the supplied sequence. Like enumerate(), you have to wrap it in list() to actually get a list out of it. You may be thinking of sorted(), which does create a new list every time (it has to, so it can sort it). – ncoghlan
upvote
  flag
@drevicko Why not reversed(enumerate(somelist)) and get the right indices immediately? – Lynn
1 upvote
  flag
@Mauris because enumerate returns an iterator and reversed expects a sequence. I guess you could do reversed(list(enumerate(somelist))) if you don't mind creating an extra list in memory. – drevicko
1 upvote
  flag
This is O(N*M) for arrays, it is very slow if you remove many items from a large list. So not recommended. – Sam Watkins
1 upvote
  flag
@SamWatkins Yeah, this answer is for when you're removing a couple of elements from a very large array. Less memory usage, but it can be m times slower. – Navin
1 upvote
  flag
Note that in Python 3 xrange was renamed to range. – Czechnology
upvote
  flag
Love this answer and tree-branch cutting analogy! List comprehension would work as well as long as you don't have to do anything complex. The only comment, I would use reversed(xrange(len(somelist))) in python2 and reversed(range(len(somelist))) in python3 – Barmaley

For those that like functional programming:

somelist[:] = filter(lambda tup: not determine(tup), somelist)

or

from itertools import ifilterfalse
somelist[:] = list(ifilterfalse(determine, somelist))
upvote
  flag
1. List comprehension and generator expressions are borrowed from Haskell, a pure functional language; they're exactly as functional as filter, and more Pythonic. 2. If you need a lambda to use map or filter, the list comp or genexpr is always the better option; map and filter can be slightly faster when the transform/predicate function is a Python built-in implemented in C and the iterable is not trivially small, but they're always slower when you need a lambda that the listcomp/genexpr could avoid. – ShadowRanger

The answers suggesting list comprehensions are ALMOST correct -- except that they build a completely new list and then give it the same name the old list as, they do NOT modify the old list in place. That's different from what you'd be doing by selective removal, as in @Lennart's suggestion -- it's faster, but if your list is accessed via multiple references the fact that you're just reseating one of the references and NOT altering the list object itself can lead to subtle, disastrous bugs.

Fortunately, it's extremely easy to get both the speed of list comprehensions AND the required semantics of in-place alteration -- just code:

somelist[:] = [tup for tup in somelist if determine(tup)]

Note the subtle difference with other answers: this one is NOT assigning to a barename - it's assigning to a list slice that just happens to be the entire list, thereby replacing the list contents within the same Python list object, rather than just reseating one reference (from previous list object to new list object) like the other answers.

1 upvote
  flag
How do I do the same sliced assignment with a dict? In Python 2.6? – PaulMcG
9 upvote
  flag
@Paul: Since dicts are unordered, slices are meaningless for dicts. If your want to replace the contents of dict a by the contents of dict b, use a.clear(); a.update(b). – Sven Marnach
1 upvote
  flag
Why can 'reseating' one of the references by replacing what the variable refers to cause bugs? It seems like that would only be a potential problem in multi-threaded applications, not single-threaded. – Derek Dahmer
46 upvote
  flag
@Derek x = ['foo','bar','baz']; y = x; x = [item for item in x if determine(item)]; This reassigns x to the result of the list comprehension, but y still refers to the original list ['foo','bar','baz']. If you expected x and y to refer to the same list, you may have introduced bugs. You prevent this by assigning to a slice of the entire list, as Alex shows, and I show here: x = ["foo","bar","baz"]; y = x; x[:] = [item for item in x if determine(item)];. The list is modified in place. ensuring that all references to the list (both x and y here) refer to the new list. – Steven T. Snyder
1 upvote
  flag
Again Alex to the rescue. He is a machine indeed. – Jakobovski
upvote
  flag
in fact, using filter function too creates a new list, does not modify elements in place... only olist[:] = [i for i in olist if not dislike(i)] – John Strood
upvote
  flag
It doesn't work , see (it skips the number 4): ` l = range(1, 6) for x in l: print x if x == 3: l = [i for i in l if i != x] ` – Dor

You might want to use filter() available as the built-in.

For more details check here

If you want to do anything else during the iteration, it may be nice to get both the index (which guarantees you being able to reference it, for example if you have a list of dicts) and the actual list item contents.

inlist = [{'field1':10, 'field2':20}, {'field1':30, 'field2':15}]    
for idx, i in enumerate(inlist):
    do some stuff with i['field1']
    if somecondition:
        xlist.append(idx)
for i in reversed(xlist): del inlist[i]

enumerate gives you access to the item and the index at once. reversed is so that the indices that you're going to later delete don't change on you.

upvote
  flag
Why is getting the index any more relevant in the case where you have a list of dicts than in the case of any other kind of list? This doesn't make sense as far as I can tell. – Mark Amery

You can try for-looping in reverse so for some_list you'll do something like:

list_len = len(some_list)
for i in range(list_len):
    reverse_i = list_len - 1 - i
    cur = some_list[reverse_i]

    # some logic with cur element

    if some_condition:
        some_list.pop(reverse_i)

This way the index is aligned and doesn't suffer from the list updates (regardless whether you pop cur element or not).

upvote
  flag
Looping over reversed(list(enumerate(some_list))) would be simpler than computing indexes yourself. – Mark Amery
upvote
  flag
@MarkAmery don't think you can alter the list this way. – Queequeg

The official Python 2 tutorial 4.2. "for Statements" says:

If you need to modify the sequence you are iterating over while inside the loop (for example to duplicate selected items), it is recommended that you first make a copy. Iterating over a sequence does not implicitly make a copy. The slice notation makes this especially convenient:

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

which is what was suggested at: //allinonescript.com/a/1207427/895245

The Python 2 documentation 7.3. "The for statement" gives the same advice:

Note: There is a subtlety when the sequence is being modified by the loop (this can only occur for mutable sequences, i.e. lists). An internal counter is used to keep track of which item is used next, and this is incremented on each iteration. When this counter has reached the length of the sequence the loop terminates. This means that if the suite deletes the current (or a previous) item from the sequence, the next item will be skipped (since it gets the index of the current item which has already been treated). Likewise, if the suite inserts an item in the sequence before the current item, the current item will be treated again the next time through the loop. This can lead to nasty bugs that can be avoided by making a temporary copy using a slice of the whole sequence, e.g.,

for x in a[:]:
    if x < 0: a.remove(x)

Could Python do this better?

It seems like this particular Python API could be improved. Compare it, for instance, with its Java counterpart ListIterator, which makes it crystal clear that you cannot modify a list being iterated except with the iterator itself, and gives you efficient ways to do so without copying the list. Come on, Python!

2 upvote
  flag
That's exactly what I was thinking... sadly something Java actually does better than Python. – Ryan
1 upvote
  flag
Java rant (edited out by //allinonescript.com/users/505088/david-heffernan) I feel that this particular Python API is significantly inferior to the Java counterpart ListIterator, which makes it crystal clear that you cannot modify a list being iterated except with the iterator itself, and gives you efficient ways to do so without copying the list. – Ciro Santilli 华涌低端人口 六四事件 法轮功
2 upvote
  flag
@DavidHeffernan I respect your opinion about whether a part of the answer is useful or not. However, I do not believe it's appropriate to delete a paragraph worth of content against the wishes of the author, especially when the content is clear and related to the question. I took the liberty to rollback your edit. – max
upvote
  flag
@CiroSantilli709大抓捕六四事件法轮功 I read the link to ListIterator, but found no statement there that prohibits modification of the list while it's iterated on. (I did see that it prohibits remove after add, and set after either remove or add, but neither of those seems to be what you're saying.) – max
2 upvote
  flag
This edit is being discussed in Meta Question @DavidHeffernan – Suraj Rao
upvote
  flag
@max I would prefer to revert the edit, I didn't because, meh :-) – Ciro Santilli 华涌低端人口 六四事件 法轮功
upvote
  flag
For record, the advantages of the comment: 1) Tell Python devs how they can make the language even better. 2) Tell Python users that there are other languages that do specific point better. – Ciro Santilli 华涌低端人口 六四事件 法轮功

I needed to do something similar and in my case the problem was memory - I needed to merge multiple dataset objects within a list, after doing some stuff with them, as a new object, and needed to get rid of each entry I was merging to avoid duplicating all of them and blowing up memory. In my case having the objects in a dictionary instead of a list worked fine:

```

k = range(5)
v = ['a','b','c','d','e']
d = {key:val for key,val in zip(k, v)}

print d
for i in range(5):
    print d[i]
    d.pop(i)
print d

```

It might be smart to also just create a new list if the current list item meets the desired criteria.

so:

for item in originalList:
   if (item != badValue):
        newList.append(item)

and to avoid having to re-code the entire project with the new lists name:

originalList[:] = newList

note, from Python documentation:

copy.copy(x) Return a shallow copy of x.

copy.deepcopy(x) Return a deep copy of x.

2 upvote
  flag
This adds no new information that wasn't in the accepted answer years earlier. – Mark Amery
2 upvote
  flag
It's simple and just another way to look at a problem @MarkAmery. It's less condensed for those people that don't like compressed coding syntax. – ntk4
upvote
  flag
originalList[:] = newList[:] is silly. Unless you are planning to use newList after, you just needlessly shallow copied it. originalList[:] = newList would work just fine and save an extra round of copying. – ShadowRanger
upvote
  flag
I am never good at remembering the different syntax in shallow vs. deep copy. Thank you for reminding me I've mixed it up again @ShadowRanger :). I've updated my response with a more thorough explanation. – ntk4

TLDR:

I wrote a library that allows you to do this:

from fluidIter import FluidIterable
fSomeList = FluidIterable(someList)  
for tup in fSomeList:
    if determine(tup):
        # remove 'tup' without "breaking" the iteration
        fSomeList.remove(tup)
        # tup has also been removed from 'someList'
        # as well as 'fSomeList'

It's best to use another method if possible that doesn't require modifying your iterable while iterating over it, but for some algorithms it might not be that straight forward. And so if you are sure that you really do want the code pattern described in the original question, it is possible.

Should work on all mutable sequences not just lists.


Full answer:

Edit: The last code example in this answer gives a use case for why you might sometimes want to modify a list in place rather than use a list comprehension. The first part of the answers serves as tutorial of how an array can be modified in place.

The solution follows on from this answer (for a related question) from senderle. Which explains how the the array index is updated while iterating through a list that has been modified. The solution below is designed to correctly track the array index even if the list is modified.

Download fluidIter.py from here https://github.com/alanbacon/FluidIterator, it is just a single file so no need to install git. There is no installer so you will need to make sure that the file is in the python path your self. The code has been written for python 3 and is untested on python 2.

from fluidIter import FluidIterable
l = [0,1,2,3,4,5,6,7,8]  
fluidL = FluidIterable(l)                       
for i in fluidL:
    print('initial state of list on this iteration: ' + str(fluidL)) 
    print('current iteration value: ' + str(i))
    print('popped value: ' + str(fluidL.pop(2)))
    print(' ')

print('Final List Value: ' + str(l))

This will produce the following output:

initial state of list on this iteration: [0, 1, 2, 3, 4, 5, 6, 7, 8]
current iteration value: 0
popped value: 2

initial state of list on this iteration: [0, 1, 3, 4, 5, 6, 7, 8]
current iteration value: 1
popped value: 3

initial state of list on this iteration: [0, 1, 4, 5, 6, 7, 8]
current iteration value: 4
popped value: 4

initial state of list on this iteration: [0, 1, 5, 6, 7, 8]
current iteration value: 5
popped value: 5

initial state of list on this iteration: [0, 1, 6, 7, 8]
current iteration value: 6
popped value: 6

initial state of list on this iteration: [0, 1, 7, 8]
current iteration value: 7
popped value: 7

initial state of list on this iteration: [0, 1, 8]
current iteration value: 8
popped value: 8

Final List Value: [0, 1]

Above we have used the pop method on the fluid list object. Other common iterable methods are also implemented such as del fluidL[i], .remove, .insert, .append, .extend. The list can also be modified using slices (sort and reverse methods are not implemented).

The only condition is that you must only modify the list in place, if at any point fluidL or l were reassigned to a different list object the code would not work. The original fluidL object would still be used by the for loop but would become out of scope for us to modify.

i.e.

fluidL[2] = 'a'   # is OK
fluidL = [0, 1, 'a', 3, 4, 5, 6, 7, 8]  # is not OK

If we want to access the current index value of the list we cannot use enumerate, as this only counts how many times the for loop has run. Instead we will use the iterator object directly.

fluidArr = FluidIterable([0,1,2,3])
# get iterator first so can query the current index
fluidArrIter = fluidArr.__iter__()
for i, v in enumerate(fluidArrIter):
    print('enum: ', i)
    print('current val: ', v)
    print('current ind: ', fluidArrIter.currentIndex)
    print(fluidArr)
    fluidArr.insert(0,'a')
    print(' ')

print('Final List Value: ' + str(fluidArr))

This will output the following:

enum:  0
current val:  0
current ind:  0
[0, 1, 2, 3]

enum:  1
current val:  1
current ind:  2
['a', 0, 1, 2, 3]

enum:  2
current val:  2
current ind:  4
['a', 'a', 0, 1, 2, 3]

enum:  3
current val:  3
current ind:  6
['a', 'a', 'a', 0, 1, 2, 3]

Final List Value: ['a', 'a', 'a', 'a', 0, 1, 2, 3]

The FluidIterable class just provides a wrapper for the original list object. The original object can be accessed as a property of the fluid object like so:

originalList = fluidArr.fixedIterable

More examples / tests can be found in the if __name__ is "__main__": section at the bottom of fluidIter.py. These are worth looking at because they explain what happens in various situations. Such as: Replacing a large sections of the list using a slice. Or using (and modifying) the same iterable in nested for loops.

As I stated to start with: this is a complicated solution that will hurt the readability of your code and make it more difficult to debug. Therefore other solutions such as the list comprehensions mentioned in David Raznick's answer should be considered first. That being said, I have found times where this class has been useful to me and has been easier to use than keeping track of the indices of elements that need deleting.


Edit: As mentioned in the comments, this answer does not really present a problem for which this approach provides a solution. I will try to address that here:

List comprehensions provide a way to generate a new list but these approaches tend to look at each element in isolation rather than the current state of the list as a whole.

i.e.

newList = [i for i in oldList if testFunc(i)]

But what if the result of the testFunc depends on the elements that have been added to newList already? Or the elements still in oldList that might be added next? There might still be a way to use a list comprehension but it will begin to lose it's elegance, and for me it feels easier to modify a list in place.

The code below is one example of an algorithm that suffers from the above problem. The algorithm will reduce a list so that no element is a multiple of any other element.

randInts = [70, 20, 61, 80, 54, 18, 7, 18, 55, 9]
fRandInts = FluidIterable(randInts)
fRandIntsIter = fRandInts.__iter__()
# for each value in the list (outer loop)
# test against every other value in the list (inner loop)
for i in fRandIntsIter:
    print(' ')
    print('outer val: ', i)
    innerIntsIter = fRandInts.__iter__()
    for j in innerIntsIter:
        innerIndex = innerIntsIter.currentIndex
        # skip the element that the outloop is currently on
        # because we don't want to test a value against itself
        if not innerIndex == fRandIntsIter.currentIndex:
            # if the test element, j, is a multiple 
            # of the reference element, i, then remove 'j'
            if j%i == 0:
                print('remove val: ', j)
                # remove element in place, without breaking the
                # iteration of either loop
                del fRandInts[innerIndex]
            # end if multiple, then remove
        # end if not the same value as outer loop
    # end inner loop
# end outerloop

print('')
print('final list: ', randInts)

The output and the final reduced list are shown below

outer val:  70

outer val:  20
remove val:  80

outer val:  61

outer val:  54

outer val:  18
remove val:  54
remove val:  18

outer val:  7
remove val:  70

outer val:  55

outer val:  9
remove val:  18

final list:  [20, 61, 7, 55, 9]
upvote
  flag
It's hard to tell whether this is over-engineered because it's unclear what problem it's trying to solve; what does removing elements using this approach achieve that some_list[:] = [x for x in some_list if not some_condition(x)] doesn't achieve? Without an answer to that, why should anyone believe that downloading and using your 600-line library complete with typos and commented-out code is a better solution to their problem than the one-liner? -1. – Mark Amery
upvote
  flag
@MarkAmery. The main use case for when this is when trying to determine if an item should be removed (or added or moved) based not on just the item itself, but on the state of another item in the list or the state of the list as a whole. For example, it is not possible with list comprehensions to write something like some_list[:] = [x for x in some_list if not some_condition(y)] where y is a different list element from x. Nor would it be possible to write some_list[:] = [x for x in some_list if not some_condition(intermediateStateOf_some_list)]. – Resonance

One possible solution, useful if you don't want to use comprehensions:

alist = ['good', 'bad', 'good', 'bad', 'good']
i = 0
for x in alist[:]:
    if x == 'bad':
        alist.pop(i)
        i -= 1
    else:
        # do something cool with x or just print x
        print x
    i += 1

This answer was originally written in response to a question which has since been marked as duplicate: Removing coordinates from list on python

There are two problems in your code:

1) When using remove(), you attempt to remove integers whereas you need to remove a tuple.

2) The for loop will skip items in your list.

Let's run through what happens when we execute your code:

>>> L1 = [(1,2), (5,6), (-1,-2), (1,-2)]
>>> for (a,b) in L1:
...   if a < 0 or b < 0:
...     L1.remove(a,b)
... 
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: remove() takes exactly one argument (2 given)

The first problem is that you are passing both 'a' and 'b' to remove(), but remove() only accepts a single argument. So how can we get remove() to work properly with your list? We need to figure out what each element of your list is. In this case, each one is a tuple. To see this, let's access one element of the list (indexing starts at 0):

>>> L1[1]
(5, 6)
>>> type(L1[1])
<type 'tuple'>

Aha! Each element of L1 is actually a tuple. So that's what we need to be passing to remove(). Tuples in python are very easy, they're simply made by enclosing values in parentheses. "a, b" is not a tuple, but "(a, b)" is a tuple. So we modify your code and run it again:

# The remove line now includes an extra "()" to make a tuple out of "a,b"
L1.remove((a,b))

This code runs without any error, but let's look at the list it outputs:

L1 is now: [(1, 2), (5, 6), (1, -2)]

Why is (1,-2) still in your list? It turns out modifying the list while using a loop to iterate over it is a very bad idea without special care. The reason that (1, -2) remains in the list is that the locations of each item within the list changed between iterations of the for loop. Let's look at what happens if we feed the above code a longer list:

L1 = [(1,2),(5,6),(-1,-2),(1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
### Outputs:
L1 is now: [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]

As you can infer from that result, every time that the conditional statement evaluates to true and a list item is removed, the next iteration of the loop will skip evaluation of the next item in the list because its values are now located at different indices.

The most intuitive solution is to copy the list, then iterate over the original list and only modify the copy. You can try doing so like this:

L2 = L1
for (a,b) in L1:
    if a < 0 or b < 0 :
        L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
print L2 is L1
del L1
L1 = L2; del L2
print ("L1 is now: ", L1)

However, the output will be identical to before:

'L1 is now: ', [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]

This is because when we created L2, python did not actually create a new object. Instead, it merely referenced L2 to the same object as L1. We can verify this with 'is' which is different from merely "equals" (==).

>>> L2=L1
>>> L1 is L2
True

We can make a true copy using copy.copy(). Then everything works as expected:

import copy
L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
L2 = copy.copy(L1)
for (a,b) in L1:
    if a < 0 or b < 0 :
        L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
del L1
L1 = L2; del L2
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]

Finally, there is one cleaner solution than having to make an entirely new copy of L1. The reversed() function:

L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
for (a,b) in reversed(L1):
    if a < 0 or b < 0 :
        L1.remove((a,b))
print ("L1 is now: ", L1)
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]

Unfortunately, I cannot adequately describe how reversed() works. It returns a 'listreverseiterator' object when a list is passed to it. For practical purposes, you can think of it as creating a reversed copy of its argument. This is the solution I recommend.

I needed to do this with a huge list, and duplicating the list seemed expensive, especially since in my case the number of deletions would be few compared to the items that remain. I took this low-level approach.

array = [lots of stuff]
arraySize = len(array)
i = 0
while i < arraySize:
    if someTest(array[i]):
        del array[i]
        arraySize -= 1
    else:
        i += 1

What I don't know is how efficient a couple of deletes are compared to copying a large list. Please comment if you have any insight.

upvote
  flag
In my case I need to move those 'unwanted' elements into another list. Do you have any new comment about this solution? I also think that it is better to use some deletions instead of duplicate the list. – GVelascoh
upvote
  flag
This is the right answer if performance is an issue (although same as @Alexey). That said, the choice of list as a data structure in the first place should be carefully considered since removal from the middle of a list takes linear time in the length of the list. If you don't really need random access to k-th sequential item, maybe consider OrderedDict? – max
upvote
  flag
@GVelascoh why not create newlist = [], and then newlist.append(array[i]) just before del array[i]? – max
upvote
  flag
Note that this is likely time inefficient: if list() is a linked list, the random access is expensive, if list() is an array, the deletes are expensive because they require to move all following elements forward. A decent iterator could make things good for the linked list implementation. This could however be space efficient. – Ciro Santilli 华涌低端人口 六四事件 法轮功

Right away you want to create a copy of the list so you can have that as a reference when you are iterating through and deleting tuples in that list that meet a certain criteria.

Then it depends on what type of list you want for the output whether that be a list of the removed tuples or a list of the tuples that are not removed.

As David pointed out, I recommend list comprehension to keep the elements you don't want to remove.

somelist = [x for x in somelist if not determine(x)]

You can write this

for i, item in enumerate(my_list):
    if condition:
        my_list.pop(i)

Here i is index and item is content.

Not the answer you're looking for? Browse other questions tagged or ask your own question.