This issue tracker has been migrated to GitHub, and is currently read-only.
For more information, see the GitHub FAQs in the Python's Developer Guide.

Title: More details in reference 'Looping through a list in Python and modifying it'
Type: enhancement Stage: resolved
Components: Documentation Versions: Python 3.7, Python 3.6
Status: closed Resolution: fixed
Dependencies: Superseder:
Assigned To: rhettinger Nosy List: docs@python, python-dev, r.david.murray, rhettinger, terry.reedy, the_darklord
Priority: normal Keywords: patch

Created on 2017-07-02 04:19 by the_darklord, last changed 2022-04-11 14:58 by admin. This issue is now closed.

Pull Requests
URL Status Linked Edit
PR 15407 merged rhettinger, 2019-08-23 04:42
PR 15410 merged miss-islington, 2019-08-23 06:44
PR 22078 closed python-dev, 2020-09-03 13:45
Messages (10)
msg297507 - (view) Author: Anmol Gupta (the_darklord) Date: 2017-07-02 04:22
Documentation section:

The documentation does not explain at all why is there an infinite loop when not using a copy of the list.

It leaves the reader in a confused state.

Even there are questions concerning the same on stackoverlflow:
msg297509 - (view) Author: Anmol Gupta (the_darklord) Date: 2017-07-02 06:29
Wrong documentaion section linked.

Correct seciton: Section 4.2 on

The last line needs more explanation.
msg297514 - (view) Author: Raymond Hettinger (rhettinger) * (Python committer) Date: 2017-07-02 12:37
The example would be more clear if we replaced the opaque idiom "words[:]" with the more explicit alternative "words.copy()".
msg297556 - (view) Author: Anmol Gupta (the_darklord) Date: 2017-07-03 10:44
And also a small explanation for why there would be an infinite loop without creating a copy.
msg297925 - (view) Author: Terry J. Reedy (terry.reedy) * (Python committer) Date: 2017-07-08 02:47
Are you looking for something like:

Let it = iter(words).  When next(it) returns 'defenestrate', insertion at the beginning moves the original 'defenestrate' over so that next(words) returns 'defenestrate' again.
msg298214 - (view) Author: R. David Murray (r.david.murray) * (Python committer) Date: 2017-07-12 13:20
I don't think that helps.  The issue here is that *sequences* are iterated over by incrementing an integer index.  If you change the size of the list, you are potentially changing which value any given index points to.  Presumably the tutorial writer thought this was intuitive, and indeed after years of Python programming I find it so.  I can see how a beginner might not, though :)

What if we replaced:

  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:


  Sequence iteration is preformed by incrementing an implicit integer index until there are no more items in the sequence.  The sequence is *not* copied before iteration, so if you modify the sequence during iteration the value that is affected by the next iteration of the loop may not be the one you are expecting.  You can avoid this problem by iterating over a copy of the sequence, and the slice notation makes this especially convenient:

However, this section has a deeper problem.  It is introducing the 'for' statement, but explains what the for statement does in terms of sequences, when in fact the for statement now operates on any iterable, not just sequences.  (Many Python programmers probably do not remember the time before the iteration protocol was added to the language :)

Fixing that problem not only requires rewriting the section, but also figuring out the best place to introduce the concept of the iteration protocol (which *might* be in this section, but it's been so long since I've looked over the tutorial that I can't say).
msg302874 - (view) Author: Raymond Hettinger (rhettinger) * (Python committer) Date: 2017-09-24 18:00
After looking at this again, I think the entire example should be removed.  We really don't want to encourage people to code like this (it would never make it through a code review).  The example itself is silly (not fully, just weird and lacking real-world motiviation).  The s.insert(0,x) code is an anti-pattern.  And in general, mutating a data structure while iterating over it is a perilous practice leading to fragile code (many data structures ban the practice outright: databases, deques, dicts).

Mutating while iterating is only safe if a data structure makes explicit guarantees about how it iterates.  In Python, we have only a handful of such guarantees (you can safely mutate dict values while iterating over the keys and lists guarantee that the iterator looks-up consecutive indicies regardless of changes to the underlying list).

I propose to remove the last two paragraphs and the example, replacing them with clear practical advice and patterns that would pass a code review.

Something like this:

    Code that modifies a collection while iterating over
    that same collection can be tricky to get right.  Instead,
    it is usually more straight-forward to loop over a copy
    of the collection or to create a new collection.

    # Strategy:  Iterate over a copy
    for user, status in users.copy():
        if status == 'inactive':
            del users[user]

    # Strategy:  Create a new collection
    active_users = {}
    for user, status in users.items():
        if status == 'active':
            active_users[user] = status
msg302884 - (view) Author: Terry J. Reedy (terry.reedy) * (Python committer) Date: 2017-09-24 19:59
I agree that the tutorial For section needs be updated to include non-sequences. A dict example will help with that.

I agree that the unrealistic insert mis-directs attention and like Raymond's replacement.  ['users.copy()' should be 'users.copy().items']
msg350253 - (view) Author: Raymond Hettinger (rhettinger) * (Python committer) Date: 2019-08-23 06:44
New changeset 6fcb6cfb139ade1aac6dbee0b18ca72b18cbe0d2 by Raymond Hettinger in branch 'master':
bpo-30826: Improve control flow examples (GH-15407)
msg350255 - (view) Author: Raymond Hettinger (rhettinger) * (Python committer) Date: 2019-08-23 06:52
New changeset b6341e676af2f58f3ad9b51a0d2fb7db5a3428e3 by Raymond Hettinger (Miss Islington (bot)) in branch '3.8':
bpo-30826: Improve control flow examples (GH-15407) (GH-15410)
Date User Action Args
2022-04-11 14:58:48adminsetgithub: 75009
2020-09-03 13:45:13python-devsetnosy: + python-dev

pull_requests: + pull_request21165
2019-08-23 06:52:47rhettingersetstatus: open -> closed
resolution: fixed
stage: patch review -> resolved
2019-08-23 06:52:18rhettingersetmessages: + msg350255
2019-08-23 06:44:29miss-islingtonsetpull_requests: + pull_request15115
2019-08-23 06:44:22rhettingersetmessages: + msg350253
2019-08-23 04:42:18rhettingersetkeywords: + patch
stage: patch review
pull_requests: + pull_request15112
2017-09-24 19:59:24terry.reedysetmessages: + msg302884
versions: + Python 3.7
2017-09-24 18:00:27rhettingersetmessages: + msg302874
2017-07-12 13:20:33r.david.murraysetnosy: + r.david.murray
messages: + msg298214
2017-07-08 02:47:20terry.reedysetnosy: + terry.reedy
messages: + msg297925
2017-07-03 10:44:14the_darklordsetmessages: + msg297556
2017-07-02 12:37:06rhettingersetassignee: docs@python -> rhettinger

messages: + msg297514
nosy: + rhettinger
2017-07-02 06:29:34the_darklordsetnosy: docs@python, the_darklord
messages: + msg297509
2017-07-02 04:22:08the_darklordsetmessages: + msg297507
2017-07-02 04:19:59the_darklordcreate