Python 当迭代器在嵌套的while循环中被覆盖时，“for i in range（）”会发生什么情况？

当迭代器在嵌套的while循环中被覆盖时，i in range（）的

会发生什么情况？例如，为什么以下代码段给出不同的输出？当我在while循环中更改变量
I
和
j
的名称时，代码段的行为与我预期的一样。但是，当while循环覆盖
i
和
j
时，
for
循环将受到影响。
for
循环的迭代器在
while
中被覆盖时，其结果行为是否可预测

（a）

（b） （与
相同的代码，而
已注释）

有订单吗

after nested for i,j 0 0
after nested for i,j 0 1
after nested for i,j 0 2
after nested for i,j 1 0
after nested for i,j 1 1
after nested for i,j 1 2
after nested for i,j 2 0
after nested for i,j 2 1
after nested for i,j 2 2

如果我清楚你的问题，那么以下是解决方案：

函数中定义的变量具有函数作用域，并且仅在函数体中可见。
您可以在不同的函数中使用相同的名称

代码1：

def VAR1():
    var = 'foo'
    def inner():
        var = 'bar'
        print 'inside function, var is ', var
    inner()
    print 'outside function, var is ', var

VAR1()

def VAR():
    var = 'foo'
    if True:
        var = 'bar'
        print 'inside if, var is ', var
    print 'outside if, var is ', var

VAR()

输出：

inside function, var is  bar
outside function, var is  foo

inside if, var is  bar
outside if, var is  bar

但在单个函数中，变量是局部的。不能在不同的地方使用相同的名称

代码1：

def VAR1():
    var = 'foo'
    def inner():
        var = 'bar'
        print 'inside function, var is ', var
    inner()
    print 'outside function, var is ', var

VAR1()

def VAR():
    var = 'foo'
    if True:
        var = 'bar'
        print 'inside if, var is ', var
    print 'outside if, var is ', var

VAR()

输出：

inside function, var is  bar
outside function, var is  foo

inside if, var is  bar
outside if, var is  bar

更多阅读
你的术语有点错误。在for循环中，您无法访问迭代器。迭代器隐藏在幕后。以下循环结构是等效的

for i in range(10):
    print(i)

it = iter(range(10)):
while True:
    try:
        i = next(it)
    except StopIteration:
        break
    print(i)

正如您所见，迭代器对象（
it
）一直隐藏在for循环中。可以在for循环中公开迭代器，但这是另一个问题

您所说的是iterable元素存储在其中的名称。如果在循环过程中重写该名称，那么该值将在循环的下一次迭代开始时被忽略。在while版本的循环结构中很容易看到这一点，其中首先要做的是将名称
i
分配给迭代器返回的下一个元素。whil

我不确定代码的用途，但可以更改您正在使用的迭代器的状态。要做到这一点，你必须写一封信。协同程序是一种能够接受输入的专用生成器

def generator_range(start, end, step=1):
    "Simplified version of the range/xrange function written as a generator."
    counter = start
    while counter < end:
        yield counter 
        counter += step

def coroutine_range(start, end, step=1):
    "Special version of range that allows the internal counter to set."
    counter = start
    while counter < end:
        sent = yield counter 
        if sent is None:
            counter += step
        else:
            counter = sent

但我们可以用协同路由做更复杂的循环算法

例如

#跳过3-7范围内的数字
l=[]
co=协程_范围（0,10）
项目发送=无
尽管如此：
尝试：
i=共同发送（项目发送至发送）
#如果要发送的项目为“无”，则上述内容与下一个相同（co）
项目发送=无
除停止迭代外：
打破
如果3我认为这确实是一个可变范围的问题
i
和
j
位于本地函数名称空间中。虽然循环不会创建新的名称空间，但在代码片段中

     while len(list) < 2:
            i = i
            j = j

您可以在本地函数名称空间中重新分配
i
和
j
，它们保存了
for
循环中的迭代值。对于
j
而言，相对良性，因为您返回到
for
的内部
循环，并且
j
被重新分配下一个迭代值。但是
x
有问题，因为它将保存更改的值，直到再次到达
的外部

您可以通过几个打印语句清楚地看到问题

for i in range (1,array.shape[0]-1):
    print('outer for, i is', i)
    for j in range (1,array.shape[1]-1):
        print('inner for, i and j are', i, j)

解决方案是使用不同的变量名。
这说明了
案例（a）
中的情况：

输出：

0 0                 # i and j set by the for statements
    new-i new-j     # i and j set by the inner assignments
new-i 1             # new j set by its for; i unchanged
    new-i new-j
1 0                 # new i and j set by for
    new-i new-j
new-i 1
    new-i new-j

i
和
j
变量没有什么特别之处，只是它们在各自循环的开始处得到了新的值。在循环之后，
i
和
j
将在循环中具有其最后的值，在这种情况下，
new-i
和
new-j

对于这样的简单循环，您可以随意摆弄
i
的值，它不会扰乱迭代（即
For
语句的操作）。但是，由于它可能会混淆您和您的算法（以及您的读者），因此为
迭代变量重新分配
通常不是一个好主意


要将迭代变量与
while
循环中的更改完全分离，需要定义如下函数：

def foo(i,j):
     print("after nested for i,j",i,j)
     counter = 0
     while counter < 3
         counter += 1
         i = counter
         j = counter

for i in range(3):
    for j in range(3):
        foo(i,j)

另一方面，如果您希望在内部
while
中进行更改以控制
i
的迭代，则还需要在外部循环中使用
while
：

i = 0
while i<3:
    j = 0
    while j<3:
        print("after nested for i,j",i,j)
        counter = 0
        while counter < 3:
            counter += 1
            i = counter
            j = counter

i=0
虽然您试图将提供的大型代码示例缩减为行为不同的最小代码段，但这里的代码太多了。这些片段是完全不同的，所以不可能说出您所问的具体问题。将它们减少到显示问题的最小值。不要隐藏内置的
列表
函数。@JakubM我已经编辑了它，因为suchIt不清楚您希望案例（a）做什么。内部
while
循环应该修改
for
循环，还是完全没有效果？您不能“摆弄值”并期望它保留其迭代值。如果算法使用
i
和
j
并期望它们是迭代值，则不能更改它们并期望算法工作。是的，这种篡改可能会扰乱您的期望。这就是为什么我说它可能会让你困惑。不，它破坏了算法。我一点也不困惑。你说改变价值是可以的，但是出于个人审美的原因应该避免。事实上，如果算法依赖于迭代值（在OP的情况下，它依赖于迭代值），你就不能改变它。我不是不同意你的观点，tdelaney！我的“your”和“you”指的是在for循环中摆弄迭代变量的假想程序员。谢谢，这是一个非常清楚的答案，完美地回答了我的问题。我本来会接受的，但另一个包括更多
0 0                 # i and j set by the for statements
    new-i new-j     # i and j set by the inner assignments
new-i 1             # new j set by its for; i unchanged
    new-i new-j
1 0                 # new i and j set by for
    new-i new-j
new-i 1
    new-i new-j

def foo(i,j):
     print("after nested for i,j",i,j)
     counter = 0
     while counter < 3
         counter += 1
         i = counter
         j = counter

for i in range(3):
    for j in range(3):
        foo(i,j)

after nested for i,j 0 0
after nested for i,j 0 1
...
after nested for i,j 2 1
after nested for i,j 2 2

i = 0
while i<3:
    j = 0
    while j<3:
        print("after nested for i,j",i,j)
        counter = 0
        while counter < 3:
            counter += 1
            i = counter
            j = counter