python - 在理解另一个类变量时引用类变量

Question

这可能是一个简单的问题，但我无法对其进行唯一搜索。

我有一个定义静态字典的类，然后尝试定义该字典的一个子集，也是静态的。

所以，作为玩具示例:

class example(object): 
    first_d = {1:1,2:2,3:3,4:4} 
    second_d = dict((k,first_d[k]) for k in (2,3))

这会产生 NameError: global name 'first_d' is not defined

我应该如何进行此引用？似乎这种模式适用于其他情况，例如:

class example2(object):
    first = 1
    second = first + 1

Answer 1

一个基本的列表推导具有以下 syntax

[expression for var in iterable]

当类内部发生列表解析时，类的属性可以在 iterable 中使用。在 Python2 和 Python3 中都是如此。

但是，类的属性可以在 Python2 的 expression 中使用(即访问)，但不能在 Python3 中使用。

生成器表达式的情况有点不同:

(expression for var in iterable)

虽然仍然可以从iterable 访问类属性，但是不能从expression 访问类属性。 (对于 Python2 和 Python3 都是如此)。

这一切可以总结如下:

                             Python2      Python3
Can access class attributes
--------------------------------------------------
list comp. iterable                Y            Y
list comp. expression              Y            N
gen expr. iterable                 Y            Y
gen expr. expression               N            N
dict comp. iterable                Y            Y
dict comp. expression              N            N

(在这方面，字典理解与生成器表达式的行为相同。)

---

现在这与您的问题有什么关系:

在你的例子中，

second_d = dict((k,first_d[k]) for k in (2,3))

NameError 发生是因为 first_d 无法从生成器表达式的 expression 部分访问。

Python2 的解决方法是将生成器表达式更改为列表理解:

second_d = dict([(k,first_d[k]) for k in (2,3)])

但是，我觉得这不是一个很舒服的解决方案，因为这段代码在 Python3 中会失败。

你可以按照 Joel Cornett 的建议去做:

second_d = {k: v for k, v in first_d.items() if k in (2, 3)}

因为这在 iterable 中使用了 first_d 而不是字典理解的 expression 部分。但是如果 first_d 包含许多项目，这可能会循环遍历比必要更多的项目。尽管如此，如果 first_d 很小，这个解决方案可能就很好。

通常，您可以通过定义一个可以在类内部或外部定义的辅助函数来避免这个问题:

def partial_dict(dct, keys):
    return {k:dct[k] for k in keys}

class Example(object):
    first_d = {1:1,2:2,3:3,4:4}
    second_d = partial_dict(first_d, (2,3))

class Example2(object):
    a = [1,2,3,4,5]
    b = [2,4]
    def myfunc(A, B):
        return [x for x in A if x not in B]
    c = myfunc(a, b)

print(Example().second_d)
# {2: 2, 3: 3}

print(Example2().c)
# [1, 3, 5]

函数之所以有效，是因为它们定义了一个局部作用域，并且可以从字典理解中访问此局部范围内的变量。

这是 explained here ，但我对此并不完全满意，因为它没有解释为什么 expression 部分的行为不同于列表理解、生成器表达式或字典理解的 iterable 部分。

因此，我无法(完全)解释 为什么 Python 会以这种方式运行，只能解释它看起来的运行方式。