我正在运行一段代码，该代码意外地在程序的某个部分出现逻辑错误。在调查该部分时，我创建了一个测试文件来测试正在运行的语句集，并发现了一个看起来很奇怪的异常错误。

我测试了这个简单的代码:

array = [1, 2, 2, 4, 5] # Original array
f = (x for x in array if array.count(x) == 2) # Filters original
array = [5, 6, 1, 2, 9] # Updates original to something else

print(list(f)) # Outputs filtered

输出是:

>>> []

是的，没什么。我希望过滤器理解能够获取数组中计数为 2 的项目并输出它，但我没有得到:

# Expected output
>>> [2, 2]

当我注释掉第三行再次测试时:

array = [1, 2, 2, 4, 5] # Original array
f = (x for x in array if array.count(x) == 2) # Filters original
### array = [5, 6, 1, 2, 9] # Ignore line

print(list(f)) # Outputs filtered

输出是正确的(你可以自己测试一下):

>>> [2, 2]

有一次我输出了变量f的类型:

array = [1, 2, 2, 4, 5] # Original array
f = (x for x in array if array.count(x) == 2) # Filters original
array = [5, 6, 1, 2, 9] # Updates original

print(type(f))
print(list(f)) # Outputs filtered

我得到了:

>>> <class 'generator'>
>>> []

为什么在 Python 中更新列表会改变另一个生成器变量的输出？这对我来说似乎很奇怪。

最佳答案

Python 的生成器表达式是后期绑定(bind)(参见 PEP 289 -- Generator Expressions)(其他答案称为“懒惰”):

Early Binding versus Late Binding

After much discussion, it was decided that the first (outermost) for-expression [of the generator expression] should be evaluated immediately and that the remaining expressions be evaluated when the generator is executed.

[...] Python takes a late binding approach to lambda expressions and has no precedent for automatic, early binding. It was felt that introducing a new paradigm would unnecessarily introduce complexity.

After exploring many possibilities, a consensus emerged that binding issues were hard to understand and that users should be strongly encouraged to use generator expressions inside functions that consume their arguments immediately. For more complex applications, full generator definitions are always superior in terms of being obvious about scope, lifetime, and binding.

这意味着它仅在创建生成器表达式时评估最外层的 for。所以它实际上 绑定(bind) 名称为 array 的值在“子表达式” in array 中(实际上它绑定(bind)了等价于 iter (数组) 此时)。但是，当您遍历生成器时，if array.count 调用实际上是指当前名为 array 的内容。

因为它实际上是一个 list 而不是 array 我在答案的其余部分更改了变量名称以更准确。

在您的第一种情况下，您迭代的 list 和您计算的 list 将是不同的。就好像你用过:

list1 = [1, 2, 2, 4, 5]
list2 = [5, 6, 1, 2, 9]
f = (x for x in list1 if list2.count(x) == 2)

因此，您检查 list1 中的每个元素是否在 list2 中的计数为 2。

您可以通过修改第二个列表轻松验证这一点:

>>> lst = [1, 2, 2]
>>> f = (x for x in lst if lst.count(x) == 2)
>>> lst = [1, 1, 2]
>>> list(f)
[1]

如果它遍历第一个列表并计入第一个列表，它将返回 [2, 2](因为第一个列表包含两个 2)。如果它迭代并计入第二个列表，则输出应为 [1, 1]。但由于它遍历第一个列表(包含一个 1)但检查第二个列表(包含两个 1)，因此输出只是一个 1。

使用生成器函数的解决方案

有几种可能的解决方案，如果不立即迭代，我通常不喜欢使用“生成器表达式”。一个简单的生成器函数就足以让它正常工作:

def keep_only_duplicated_items(lst):
    for item in lst:
        if lst.count(item) == 2:
            yield item

然后像这样使用它:

lst = [1, 2, 2, 4, 5]
f = keep_only_duplicated_items(lst)
lst = [5, 6, 1, 2, 9]

>>> list(f)
[2, 2]

请注意，PEP(请参阅上面的链接)还指出，对于更复杂的事情，最好使用完整的生成器定义。

使用带有计数器的生成器函数的更好解决方案

更好的解决方案(避免二次运行时行为，因为您为数组中的每个元素迭代整个数组)是计算(collections.Counter)元素一次，然后在恒定时间内进行查找(导致线性时间):

from collections import Counter

def keep_only_duplicated_items(lst):
    cnts = Counter(lst)
    for item in lst:
        if cnts[item] == 2:
            yield item

附录:使用子类“可视化”发生了什么以及何时发生

创建一个在调用特定方法时打印的 list 子类非常容易，因此可以验证它是否真的像那样工作。

在这种情况下，我只是重写方法 __iter__ 和 count 因为我对生成器表达式迭代哪个列表以及它在哪个列表中计数感兴趣。方法体实际上只是委托(delegate)给父类(super class)并打印一些东西(因为它使用 super 没有参数和 f-strings 它需要 Python 3.6，但它应该很容易适应其他 Python 版本):

class MyList(list):
    def __iter__(self):
        print(f'__iter__() called on {self!r}')
        return super().__iter__()
        
    def count(self, item):
        cnt = super().count(item)
        print(f'count({item!r}) called on {self!r}, result: {cnt}')
        return cnt

这是一个简单的子类，仅在调用 __iter__ 和 count 方法时打印:

>>> lst = MyList([1, 2, 2, 4, 5])

>>> f = (x for x in lst if lst.count(x) == 2)
__iter__() called on [1, 2, 2, 4, 5]

>>> lst = MyList([5, 6, 1, 2, 9])

>>> print(list(f))
count(1) called on [5, 6, 1, 2, 9], result: 1
count(2) called on [5, 6, 1, 2, 9], result: 1
count(2) called on [5, 6, 1, 2, 9], result: 1
count(4) called on [5, 6, 1, 2, 9], result: 0
count(5) called on [5, 6, 1, 2, 9], result: 1
[]

关于python - 条件生成器表达式的意外行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54245618/