Question

解释我的问题的最好方法是举个例子：

example.py：

class A(object):
    integers = [1, 2, 3]
    singles = [i for i in integers]

class B(object):
    integers = [1, 2, 3]
    pairs = [(i, j) for i in integers for j in integers]

当我在python 2下运行时，它工作正常，但在python 3下我得到NameError类B（但不是类A）：

$ python example.py
Traceback (most recent call last):
  File "example.py", line 6, in <module>
    class B(object):
  File "example.py", line 8, in B
    pairs = [(i, j) for i in integers for j in integers]
  File "example.py", line 8, in <listcomp>
    pairs = [(i, j) for i in integers for j in integers]
NameError: global name 'integers' is not defined

为什么只有B课提出NameError以及为什么只在Python 3下？

Answer 1

类Python在Python 3中有点奇怪，但它有充分的理由。

在Python 2中，迭代变量（示例中的i和j）从列表推导中泄露出来，并将包含在外部范围内。这是因为它们是在Python 2的设计早期开发的，它们基于显式循环。作为出乎意料的示例，请检查Python 2中B.i和B.j的值，但没有出现错误！

在Python 3中，列表推导已更改以防止此泄漏。它们现在使用一个函数（具有自己的作用域）来实现，该函数被调用以生成列表值。这使得它们与生成器表达式的工作方式相同，生成器表达式一直是功能。

这样做的结果是，在类中，列表推导通常看不到任何类变量。这与无法直接查看类变量的方法（仅self或显式类名）并行。例如，调用下面的类中的方法将提供您在列表推导中看到的相同NameError异常：

class Foo:
    classvar = "bar"
    def blah(self):
        print(classvar) # raises "NameError: global name 'classvar' is not defined"

但是有一个例外。由列表推导的第一个for子句迭代的序列在内部函数之外进行计算。这就是为什么你的A类在Python 3中工作的原因。这样做可以使生成器立即捕获不可迭代的对象（而不是仅在它们调用next并且它们的代码运行时）。

但它不适用于类for中两级理解中的内部B子句。

如果使用dis模块反汇编某些创建列表推导的函数，则可以看出区别：

def f(lst):
    return [i for i in lst]

def g(lst):
    return [(i, j) for i in lst for j in lst]

以下是f的反汇编：

>>> dis.dis(f)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x0000000003CCA1E0, file "<pyshell#374>", line 2>) 
              3 LOAD_CONST               2 ('f.<locals>.<listcomp>') 
              6 MAKE_FUNCTION            0 
              9 LOAD_FAST                0 (lst) 
             12 GET_ITER             
             13 CALL_FUNCTION            1 (1 positional, 0 keyword pair) 
             16 RETURN_VALUE

前三行显示f加载预编译的代码块并从中创建一个函数（它将其命名为f.<locals>.<listcomp>）。这是用于制作列表的函数。

接下来的两行显示正在加载的lst变量以及从中生成的迭代器。这发生在f范围内，而不是内部函数。然后调用<listcomp>函数，并将迭代器作为参数。

这与班级A相当。它从类变量integers获取迭代器，就像您可以在新成员的定义中使用对先前类成员的其他类型的引用一样。

现在，比较g的反汇编，它通过迭代两次相同的列表来生成对：

>>> dis.dis(g)
  2           0 LOAD_CLOSURE             0 (lst) 
              3 BUILD_TUPLE              1 
              6 LOAD_CONST               1 (<code object <listcomp> at 0x0000000003CCA810, file "<pyshell#377>", line 2>) 
              9 LOAD_CONST               2 ('g.<locals>.<listcomp>') 
             12 MAKE_CLOSURE             0 
             15 LOAD_DEREF               0 (lst) 
             18 GET_ITER             
             19 CALL_FUNCTION            1 (1 positional, 0 keyword pair) 
             22 RETURN_VALUE

这次，它使用代码对象而不是基本函数构建闭包。闭包是一个带有一些“自由”变量的函数，这些变量引用封闭范围内的东西。对于<listcomp>中的g函数，这很好用，因为它的范围是正常的。但是，当你尝试在类B中使用相同类型的理解时，闭包失败，因为类不允许它们包含的函数以这种方式看到它们的作用域（如上面的Foo类所示）。 / p>

值得注意的是，不仅内部序列值会导致此问题。与在评论中由BrenBarn链接的previous question一样，如果在列表推导中的其他位置引用类变量，则会遇到相同的问题：

class C:
    num = 5
    products = [i * num for i in range(10)] # raises a NameError about num

但是，您不会从多级列表推导中得到错误，其中内部for（或if）子句仅引用前一循环的结果。这是因为这些值不是闭包的一部分，只是<listcomp>函数范围内的局部变量。

class D:
    nested = [[1, 2, 3], [4, 5, 6]]
    flattened = [item for inner in nested for item in inner] # works!

就像我说的那样，课程范围有点奇怪。

嵌套列表理解范围

1 个答案: