为什么在for-loops中允许使用任意的目标表达式？

Question

我不小心写了一些这样的代码：

foo = [42] 
k = {'c': 'd'} 

for k['z'] in foo: # Huh?? 
    print k 

然而令我惊讶，这不是一个语法错误。相反，它打印{'c': 'd', 'z': 42}。

我猜测是代码被翻译字面上是这样的：

i = iter(foo) 
while True: 
    try: 
     k['z'] = i.next() # literally translated to assignment; modifies k! 
     print k 
    except StopIteration: 
     break 

但是......这是为什么允许的语言？我期望在for-stmt's target expression中只能使用单个标识符和标识符元组。有没有什么情况下，这实际上是有用的，而不仅仅是一个奇怪的陷阱？

Answer 1

的for循环如下分配的标准规则上香草转让的LHS所以什么工作应与工作for：

而每个项目使用标准 规则分配给目标清单用于分配

的for构建简单地召唤的基本机制用于分配到目标这在示例代码的情况下是STORE_SUBSCR：

>>> foo = [42] 
>>> k = {'c': 'd'} 
>>> dis.dis('for k["e"] in foo: pass') 
    1   0 SETUP_LOOP    16 (to 18) 
       2 LOAD_NAME    0 (foo) 
       4 GET_ITER 
     >> 6 FOR_ITER     8 (to 16) 
       8 LOAD_NAME    1 (k) 
      10 LOAD_CONST    0 ('e') 
      12 STORE_SUBSCR <-------------------- 
      14 JUMP_ABSOLUTE   6 
     >> 16 POP_BLOCK 
     >> 18 LOAD_CONST    1 (None) 
      20 RETURN_VALUE 

然而令我惊讶，这不是一个语法错误

显然，在常规分配任何工作，如下列：

全切片分配：

>>> for [][:] in []: 
... pass 
... 
>>> 

列表订阅

>>> for [2][0] in [42]: 
... pass 
... 
>>> 

字典订阅等将是有效的候选目标，其中唯一的例外是一个链分配;尽管，我暗自认为可以用一些肮脏的语法来进行链接。

---

我希望只有一个标识符和标识符

我想不出很好的利用情况的字典键为目标的元组。此外，在循环体中执行字典键分配的可读性要高于在for子句中将其用作目标的可读性。

然而，扩展拆包（Python 3中），这是在常规的作业非常有用还附带同样方便在for循环中：

>>> lst = [[1, '', '', 3], [3, '', '', 6]] 
>>> for x, *y, z in lst: 
... print(x,y,z) 
... 
1 ['', ''] 3 
3 ['', ''] 6 

用于分配到不同的目标这里也被召唤相应的机构;多STORE_NAME S：

>>> dis.dis('for x, *y, z in lst: pass') 
    1   0 SETUP_LOOP    20 (to 22) 
       2 LOAD_NAME    0 (lst) 
       4 GET_ITER 
     >> 6 FOR_ITER    12 (to 20) 
       8 EXTENDED_ARG    1 
      10 UNPACK_EX    257 
      12 STORE_NAME    1 (x) <----- 
      14 STORE_NAME    2 (y) <----- 
      16 STORE_NAME    3 (z) <----- 
      18 JUMP_ABSOLUTE   6 
     >> 20 POP_BLOCK 
     >> 22 LOAD_CONST    0 (None) 
      24 RETURN_VALUE 

正好说明一个for是连续执行勉强简单的赋值语句。

Answer 2

有没有什么情况下这实际上有用？

确实。曾经想摆脱itertools.combinations？

def combinations (pool, repeat):   
    def combinations_recurse (acc, pool, index = 0): 
     if index < len(acc): 
      for acc[index] in pool: 
       yield from combinations_recurse(acc, pool, index + 1) 
     else: 
      yield acc 

    yield from combinations_recurse([pool[0]] * repeat, pool) 

for comb in combinations([0, 1], 3): 
    print(comb) 

Answer 3

下面的代码会有意义，对吧？

foo = [42] 
for x in foo: 
    print x 

的for循环会遍历列表foo和每个对象依次以当前名字空间分配给名称x。结果将是一次迭代和单个打印42。

代替你的代码中的x，你有k['z']。 k['z']是有效的存储名称。在我的例子中，像x，它还不存在。实际上，它在全局命名空间中为k.z。该循环创建k.z或k['z']并将它在foo中找到的值赋值给它，方法与创建x的方法相同，并在我的示例中将值赋给它。如果你曾在富更值...

foo = [42, 51, "bill", "ted"] 
k = {'c': 'd'} 
for k['z'] in foo: 
    print k 

会导致：

{'c': 'd', 'z': 42} 
{'c': 'd', 'z': 51} 
{'c': 'd', 'z': 'bill'} 
{'c': 'd', 'z': 'ted'} 

你写的完全合法的意外代码。这甚至不是奇怪的代码。您通常不会将字典条目视为变量。

即使代码并不奇怪，如何让这样的任务有用呢？

key_list = ['home', 'car', 'bike', 'locker'] 
loc_list = ['under couch', 'on counter', 'in garage', 'in locker'] 
chain = {} 
for index, chain[key_list[index]] in enumerate(loc_list): 
    pass 

可能不是最好的方法来做到这一点，而是把两个相等长度的列表放到字典中。我相信还有其他更有经验的程序员在for循环中使用了字典键分配。也许...

Answer 4

每个名字只是一个字典键*。

for x in blah: 

恰恰是

for vars()['x'] in blah: 

*（尽管这字典不需要被实现为实际dict对象，在一些优化，的情况下，如在函数作用域）。