使用列表生成器时，Python3中的pdb模块可能存在错误

Question

在Python 3中运行此代码后：

import pdb
def foo():
    nums = [1, 2, 3]
    a = 5
    pdb.set_trace()
foo()

以下表达式有效：

(Pdb) print(nums)
[1, 2, 3]
(Pdb) print(a)
5
(Pdb) [x for x in nums]
[1, 2, 3]

但以下表达式失败：

(Pdb) [x*a for x in nums]
*** NameError: global name 'a' is not defined

以上内容在Python 2.7中运行良好。

这是bug还是我遗漏了什么？

更新：查看新接受的答案。这确实是一个错误（或有问题的设计），现在已经通过在pdb中引入新的命令和模式来解决。

Answer 1

如果您在[i]pdb会话中键入interact，您将获得一个交互式会话，并且列表理解在这种模式下可以正常工作

来源：http://bugs.python.org/msg215963

Answer 2

它运行得非常好：

>>> import pdb
>>> def f(seq):
...     pdb.set_trace()
... 
>>> f([1,2,3])
--Return--
> <stdin>(2)f()->None
(Pdb) [x for x in seq]
[1, 2, 3]
(Pdb) [x in seq for x in seq]
[True, True, True]

如果不展示你实际在做什么，没有人能告诉你为什么在你的特定情况下你会得到NameError。

---

TL；DR在python3中，列表理解实际上是具有自己堆栈框架的函数，并且不能从内部堆栈框架访问seq变量，它是test的参数。相反，它被视为全局（因此未找到）。

---

您看到的是python2和python3中列表理解的不同实现。在python 2中，列表理解实际上是for循环的一个捷径，您可以在字节码中清楚地看到这一点：

>>> def test(): [x in seq for x in seq]
... 
>>> dis.dis(test)
  1           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (seq)
              6 GET_ITER            
        >>    7 FOR_ITER                18 (to 28)
             10 STORE_FAST               0 (x)
             13 LOAD_FAST                0 (x)
             16 LOAD_GLOBAL              0 (seq)
             19 COMPARE_OP               6 (in)
             22 LIST_APPEND              2
             25 JUMP_ABSOLUTE            7
        >>   28 POP_TOP             
             29 LOAD_CONST               0 (None)
             32 RETURN_VALUE        

注意字节码是如何包含FOR_ITER循环的。另一方面，在python3中，列表理解实际上是函数，它们有自己的堆栈框架：

>>> def test(): [x in seq2 for x in seq]
... 
>>> dis.dis(test)
  1           0 LOAD_CONST               1 (<code object <listcomp> at 0xb6fef160, file "<stdin>", line 1>) 
              3 MAKE_FUNCTION            0 
              6 LOAD_GLOBAL              0 (seq) 
              9 GET_ITER             
             10 CALL_FUNCTION            1 
             13 POP_TOP              
             14 LOAD_CONST               0 (None) 
             17 RETURN_VALUE      

正如您所看到的，这里没有FOR_ITER，取而代之的是MAKE_FUNCTION和CALL_FUNCTION字节码。如果我们检查列表理解的代码，我们就可以理解绑定是如何设置的：

>>> test.__code__.co_consts[1]
<code object <listcomp> at 0xb6fef160, file "<stdin>", line 1>
>>> test.__code__.co_consts[1].co_argcount   # it has one argument
1
>>> test.__code__.co_consts[1].co_names      # global variables
('seq2',)
>>> test.__code__.co_consts[1].co_varnames   # local variables
('.0', 'x')

这里.0是函数的唯一自变量。x是循环的局部变量，seq2是全局变量。注意，列表理解参数.0是从seq获得的可迭代参数，而不是seq本身。（请参阅上面dis输出中的GET_ITER操作码）。这一点在一个更复杂的例子中更为清楚：

>>> def test():
...     [x in seq for x in zip(seq, a)]
... 
>>> dis.dis(test)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0xb7196f70, file "<stdin>", line 2>) 
              3 MAKE_FUNCTION            0 
              6 LOAD_GLOBAL              0 (zip) 
              9 LOAD_GLOBAL              1 (seq) 
             12 LOAD_GLOBAL              2 (a) 
             15 CALL_FUNCTION            2 
             18 GET_ITER             
             19 CALL_FUNCTION            1 
             22 POP_TOP              
             23 LOAD_CONST               0 (None) 
             26 RETURN_VALUE 
>>> test.__code__.co_consts[1].co_varnames
('.0', 'x')

在这里，您可以看到，列表理解的唯一自变量（总是用.0表示）是从zip(seq, a)获得的可迭代性。CCD_ 20和CCD_。只有iter(zip(seq, a))在列表理解中通过。

我们必须注意的另一点是，当您运行pdb时，您无法从要定义的函数访问当前函数的上下文。例如，以下代码在python2和python3上都失败：

>>> import pdb
>>> def test(seq): pdb.set_trace()
... 
>>> test([1,2,3])
--Return--
> <stdin>(1)test()->None
(Pdb) def test2(): print(seq)
(Pdb) test2()
*** NameError: global name 'seq' is not defined

它之所以失败，是因为在定义test2时，seq变量被视为全局变量，但它实际上是test函数内的局部变量，因此无法访问。

您看到的行为类似于以下场景：

#python 2 no error
>>> class A(object):
...     x = 1
...     L = [x for _ in range(3)]
... 
>>> 
#python3 error!
>>> class A(object):
...     x = 1
...     L = [x for _ in range(3)]
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in A
  File "<stdin>", line 3, in <listcomp>
NameError: global name 'x' is not defined

第一个没有给出错误，因为它主要相当于：

>>> class A(object):
...     x = 1
...     L = []
...     for _ in range(3): L.append(x)
... 

由于列表理解是在字节码中"扩展"的。在python3中，它失败了，因为您实际上正在定义一个函数，并且无法从嵌套函数范围访问类范围：

>>> class A(object):
...     x = 1
...     def test():
...             print(x)
...     test()
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in A
  File "<stdin>", line 4, in test
NameError: global name 'x' is not defined

请注意，genexp是作为函数在python2上实现的，事实上，您可以看到它们的类似行为（在python2和python3上）：

>>> import pdb
>>> def test(seq): pdb.set_trace()
... 
>>> test([1,2,3])
--Return--
> <stdin>(1)test()->None
(Pdb) list(x in seq for x in seq)
*** Error in argument: '(x in seq for x in seq)'

这里pdb没有给你更多的细节，但失败发生的原因完全相同。

---

总之：这不是pdb中的错误，而是python实现作用域的方式。AFAIK将其更改为允许您在pdb中尝试执行的操作需要对函数的处理方式进行一些重大更改，我不知道是否可以在不修改解释器的情况下完成这一操作。

---

注意，当使用嵌套列表理解时，嵌套循环在字节码中进行扩展，就像python2:中的列表理解一样

>>> import dis
>>> def test(): [x + y for x in seq1 for y in seq2]
... 
>>> dis.dis(test)
  1           0 LOAD_CONST               1 (<code object <listcomp> at 0xb71bf5c0, file "<stdin>", line 1>) 
              3 MAKE_FUNCTION            0 
              6 LOAD_GLOBAL              0 (seq1) 
              9 GET_ITER             
             10 CALL_FUNCTION            1 
             13 POP_TOP              
             14 LOAD_CONST               0 (None) 
             17 RETURN_VALUE         
>>> # The only argument to the listcomp is seq1
>>> import types
>>> func = types.FunctionType(test.__code__.co_consts[1], globals())
>>> dis.dis(func)
  1           0 BUILD_LIST               0 
              3 LOAD_FAST                0 (.0) 
        >>    6 FOR_ITER                29 (to 38) 
              9 STORE_FAST               1 (x) 
             12 LOAD_GLOBAL              0 (seq2) 
             15 GET_ITER             
        >>   16 FOR_ITER                16 (to 35) 
             19 STORE_FAST               2 (y) 
             22 LOAD_FAST                1 (x) 
             25 LOAD_FAST                2 (y) 
             28 BINARY_ADD           
             29 LIST_APPEND              3 
             32 JUMP_ABSOLUTE           16 
        >>   35 JUMP_ABSOLUTE            6 
        >>   38 RETURN_VALUE        

正如您所看到的，listcomp的字节码在seq2上有一个显式的FOR_ITER。此显式FOR_ITER位于listcomp函数内部，因此对作用域的限制仍然适用（例如，seq2作为全局加载）。

事实上，我们可以使用pdb:来确认这一点

>>> import pdb
>>> def test(seq1, seq2): pdb.set_trace()
... 
>>> test([1,2,3], [4,5,6])
--Return--
> <stdin>(1)test()->None
(Pdb) [x + y for x in seq1 for y in seq2]
*** NameError: global name 'seq2' is not defined
(Pdb) [x + y for x in non_existent for y in seq2]
*** NameError: name 'non_existent' is not defined

注意NameError是关于seq2而不是seq1（作为函数参数传递）的，注意将第一个可迭代名称更改为不存在的名称是如何更改NameError的（这意味着在第一种情况下seq1成功传递）。

Answer 3

我只是不明白，如果你想为seq中的每个元素生成一个Trues列表，为什么你需要执行上述操作，那么为什么不[在seq中为x生成True]呢？我想，在尝试这种操作之前，你需要先分配一个本地副本。