嵌套列表理解范围

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下，我得到了NameErrorfor类B（但不是class 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

为什么只有class会B引发a NameError，为什么只在Python 3下？

Answer 1

类作用域在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调用它们并运行其代码时捕获）。

但这对于forclass的二级理解中的内部子句不起作用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类所示）。

值得注意的是，不仅内部序列值也会导致此问题。与BrenBarn在评论中链接的上一个问题一样，如果在列表理解的其他地方引用了类变量，您也会遇到相同的问题：

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!

就像我说的那样，类作用域有点奇怪。