You shouldn't modify the list while iterating over it. It leads to weirdness like this.

The first test isn't surprising; three elements are removed off the end.

The second test is a bit surprising. Only two elements are removed. Why?

List iteration in Python essentially consists of an incrementing index into the list. When you delete an element you shift all the elements on the right over. This may cause the index to point to a different element.

Illustratively:

start of loop
[0,0,0,1,2,3,4,5,6]
 ^   <-- position of index

delete first element (since current element = 0)
[0,0,1,2,3,4,5,6]
 ^

next iteration
[0,0,1,2,3,4,5,6]
   ^

delete first element (since current element = 0)
[0,1,2,3,4,5,6]
   ^

and from now on no zeros are encountered, so no more elements are deleted.

---

To avoid confusion in the future, try not to modify lists while you're iterating over them. While Python won't complain (unlike dictionaries, which cannot be modified during iteration), it will result in weird and usually counterintuitive situations like this one.

Nice observation! You are correct in that the performance of pop(0) is significantly slower than pop() for large lists (above 10,000 elements). See timeit results below. I believe @Kenneth Love (https://teamtreehouse.com/kennethlove) chose to pop from the front of the list as a straight-forward logical approach without trying to optimize for performance. Since the order of monsters in the list is arbitrary, popping from the back or the front isn't a requirement and either approach would work functionally. Using timeit in the python REPL: ```python import timeit stmt1 = "while foo: it = foo.pop();" stmt2 = "while foo: it = foo.pop(0);" Run on 1000 element list setup = "foo = list(range(1000))" timeit.timeit(stmt1, setup) 0.051728010177612305 timeit.timeit(stmt2, setup) 0.05761384963989258 Run on 10,000 element list setup = "foo = list(range(10000))" timeit.timeit(stmt1, setup) 0.05236983299255371 timeit.timeit(stmt2, setup) 0.06780695915222168 Run on 100,000 element list setup = "foo = list(range(100000))" timeit.timeit(stmt1, setup) 0.0552210807800293 timeit.timeit(stmt2, setup) 1.3619050979614258 Run on 1,000,000 element list setup = "foo = list(range(1000000))" timeit.timeit(stmt1, setup) 0.10635495185852051 timeit.timeit(stmt2, setup) 226.78901600837708 ```

deque.popleft() is faster than list.pop(0), because the deque has been optimized to do popleft() approximately in O(1), while list.pop(0) takes O(n) (see deque objects).

Comments and code in _collectionsmodule.c for deque and listobject.c for list provide implementation insights to explain the performance differences. Namely that a deque object "is composed of a doubly-linked list", which effectively optimizes appends and pops at both ends, while list objects are not even singly-linked lists but C arrays (of pointers to elements (see Python 2.7 listobject.h#l22 and Python 3.5 listobject.h#l23), which makes them good for fast random access of elements but requires O(n) time to reposition all elements after removal of the first.

For Python 2.7 and 3.5, the URLs of these source code files are:

1. https://hg.python.org/cpython/file/2.7/Modules/_collectionsmodule.c

2. https://hg.python.org/cpython/file/2.7/Objects/listobject.c

3. https://hg.python.org/cpython/file/3.5/Modules/_collectionsmodule.c

4. https://hg.python.org/cpython/file/3.5/Objects/listobject.c

Using %timeit, the performance difference between deque.popleft() and list.pop(0) is about a factor of 4 when both the deque and the list have the same 52 elements and grows to over a factor of 1000 when their lengths are 10**8. Test results are given below.

import string
from collections import deque

%timeit d = deque(string.letters); d.popleft()
1000000 loops, best of 3: 1.46 µs per loop

%timeit d = deque(string.letters)
1000000 loops, best of 3: 1.4 µs per loop

%timeit l = list(string.letters); l.pop(0)
1000000 loops, best of 3: 1.47 µs per loop

%timeit l = list(string.letters);
1000000 loops, best of 3: 1.22 µs per loop

d = deque(range(100000000))

%timeit d.popleft()
10000000 loops, best of 3: 90.5 ns per loop

l = range(100000000)

%timeit l.pop(0)
10 loops, best of 3: 93.4 ms per loop