First of all a disclaimer:

I don’t want to use a code like this,I am aware it is a bad practice. As well I am not interested in tips on how to improve it,to make it right. What interests me is a theory.

为什么这样的代码在python 3.6中有效：

ls = range(5)
for elem_a in ls:

    ls = range(5,10)
    for elem_b in ls:
        print(elem_a,elem_b)

我在迭代它时重新分配ls的值.在ls中第一次执行elem_a时,第一次迭代中的ls值是否存储在内存中？

基本上如果你有这样的循环：

seq = range(5)
for elem in seq:
    seq = something_else

Python将其重写为以下内容：

seq = range(5)

loop_iter = iter(seq)  # obtain an iterator
while True:
    try:
        elem = next(loop_iter)  # get the next element from the iterator
    except stopiteration:
        break  # the iterator is exhausted,end the loop

    # execute the loop body
    seq = something_else

这个的关键方面是循环有自己对iter(seq)的引用存储在loop_iter中,所以自然地重新分配seq对循环没有影响.

所有这些都在compound statement documentation中解释：

06002

The expression list is evaluated once; it should yield an iterable
object. An iterator is created for the result of the expression_list. The suite is then executed once for each item provided by the iterator,in the order returned by the iterator.

class DummyIterator:
    def __init__(self,max_value):
        self.max_value = max_value

    def __iter__(self):
        for i in range(self.max_value):
            yield i

def regular_dummy_iterator(max_value):
    for i in range(max_value):
        yield i

这允许我多次迭代该值,以便我可以实现这样的事情：

def normalise(data):
    total = sum(i for i in data)
    for val in data:
        yield val / total

# this works when I call next()
normalise(DummyIterator(100))

# this doesn't work when I call next()
normalise(regular_dummy_iterator(100))

如何检查normalize函数,我正在传递一个迭代器容器而不是一个普通的生成器？

迭代生成迭代器.任何迭代器也是可迭代的,但它自己生成迭代器：

>>> list_iter = iter([])
>>> iter(list_iter) is list_iter
True

如果iter(ob)是ob test,则没有迭代器.