python - 为什么 "class"不像 "def"那样启动一个新范围？

Question

我不完全确定这是针对 stackoverflow 的，所以如果不是，请纠正我。

即假设我们有包含以下内容的 t.py:

class A(object):
    pass
print("A:", A)

class B(object):
    print("From B: A:", A)


class OuterClass(object):
    class AA(object):
        pass
    print("AA:", AA)

    class BB(object):
        print("From BB: AA:", AA)

现在我们执行它:$ python3 t.py

A: <class '__main__.A'>
From B: A: <class '__main__.A'>
AA: <class '__main__.AA'>
From BB: AA:
Traceback (most recent call last):
  File "t.py", line 9, in <module>
    class OuterClass(object):
  File "t.py", line 14, in OuterClass
    class BB(object):
  File "t.py", line 15, in BB
    print "From BB: AA:", AA
NameError: name 'AA' is not defined

来自文档:

A class definition is an executable statement. It first evaluates the inheritance list, if present. Each item in the inheritance list should evaluate to a class object or class type which allows subclassing. The class’s suite is then executed in a new execution frame (see section Naming and binding), using a newly created local namespace and the original global namespace. (Usually, the suite contains only function definitions.) When the class’s suite finishes execution, its execution frame is discarded but its local namespace is saved. [4] A class object is then created using the inheritance list for the base classes and the saved local namespace for the attribute dictionary. The class name is bound to this class object in the original local namespace.

所以我理解这种行为，但不理解使作用域不像其他地方那样是词法的背后的基本原理。这违背了“特殊情况不足以违反规则”。为什么 class 的行为不同于 def？

这是一个“实用胜过纯粹”的案例吗？如果是这样，理由是什么？我最初认为它可能是 python 2.x 的产物，但正如您在上面看到的那样，该行为也存在于 python 3.3 中。

Answer 1

正如 Wooble 在评论中指出的那样，类 block 确实 创建了一个新范围。问题是类 block 作用域中的名称对于嵌套在该作用域内的作用域是不可访问的。 the documentation 中提到了这一点:

The scope of names defined in a class block is limited to the class block; it does not extend to the code blocks of methods – this includes comprehensions and generator expressions since they are implemented using a function scope.

我现在找不到它的来源，但是在某个地方(我想在 StackOverflow 的一个问题上)我找到了一个合理的理由:如果类 def 可以在嵌套 block 中访问，方法名称将隐藏全局函数，包括内置的。这会使创建的类的方法名称简短、但又使用同名的内置函数变得很尴尬。例如，您不能这样做:

class SomeDataStructure(object):
    def sum(self):
        return sum(self._data)
    def otherCalc(self):
        return sum(item for item in somethingElse)

如果类 block 在方法范围内，这将导致无限递归，因为内部 sum 调用可以访问方法名称并调用该方法而不是内置 求和函数。同样，其他方法(例如 otherCalc 方法)将不再有权访问全局求和函数以供自己使用，但始终可以获取该方法。 An answer to another SO question通过说“这是因为你应该使用 self 来访问 Python 中的方法”来描述这一点。

现在，这个论点实际上只对类内部的函数有意义，因为当 def 时函数体不会被执行，但是类体 在 class 语句时执行。但是，我认为如果将我上面所说的内容与 this blog post 中的概念结合起来，你得到一个合理的理由。也就是说，嵌套类过去不是——现在仍然不是——被认为是一种值得支持的风格。不过，类中的函数当然很常见。处理类内部函数用例的最简单方法是使 class block 不将其名称传递给任何 嵌套范围。如果将其名称传递给嵌套类而不是嵌套函数，可以说会更好，但这将是一个更复杂的规则，而且没有人足够关心支持嵌套类以使其值得。