在函数内创建类并访问包含函数范围内定义的函数

74

编辑：

请参阅此问题底部的我的完整答案。

tl; dr答：Python具有静态嵌套的作用域。的静态 方面可以与隐变量声明相互作用，产生非显而易见的结果。

（由于该语言通常具有动态特性，所以这尤其令人惊讶）。

我以为我对Python的作用域规则掌握得很好，但是这个问题使我彻底陷入困境，而我的google-fu让我失败了（这并不令我感到惊讶-查看问题标题;）

我将从一些可以按预期工作的示例开始，但是请多跳到示例4。

范例1。

>>> x = 3
>>> class MyClass(object):
...     x = x
... 
>>> MyClass.x
3

很简单：在类定义期间，我们能够访问外部（在本例中为全局）范围内定义的变量。

示例2

>>> def mymethod(self):
...     return self.x
... 
>>> x = 3
>>> class MyClass(object):
...     x = x
...     mymethod = mymethod
...
>>> MyClass().mymethod()
3

再次（暂时忽略为什么要这样做），这里没有什么意外的：我们可以访问外部作用域中的函数。

注意：正如Frédéric在下面指出的那样，此功能似乎无效。请参见示例5（及以后）。

范例3。

>>> def myfunc():
...     x = 3
...     class MyClass(object):
...         x = x
...     return MyClass
... 
>>> myfunc().x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in myfunc
  File "<stdin>", line 4, in MyClass
NameError: name 'x' is not defined

基本上与示例1相同：我们要从类定义中访问外部范围，这一次是由于范围不是全局的myfunc()。

编辑5：正如下面的@ user3022222指出的那样，我在原始帖子中弄虚了这个示例。我相信这会失败，因为只有函数（其他代码块（如此类定义）无法访问封闭范围内的变量）。对于非功能代码块，只能访问局部变量，全局变量和内置变量。这个问题有更详尽的解释

多一个：

范例4。

>>> def my_defining_func():
...     def mymethod(self):
...         return self.y
...     class MyClass(object):
...         mymethod = mymethod
...         y = 3
...     return MyClass
... 
>>> my_defining_func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in my_defining_func
  File "<stdin>", line 5, in MyClass
NameError: name 'mymethod' is not defined

嗯...不好意思

是什么使它与示例2不同？

我完全迷住了。请把我整理一下。谢谢！

PS偶然地认为这不仅仅是我的理解问题，我已经在Python 2.5.2和Python 2.6.2上进行了尝试。不幸的是，这些都是我目前可以使用的，但是它们都表现出相同的行为。

根据http://docs.python.org/tutorial/classes.html#python-scopes-and-namespaces进行编辑：在执行期间的任何时候，至少有三个嵌套作用域可以直接访问其命名空间：

  • 最里面的作用域（首先搜索）包含本地名称
  • 从最近的封闭范围开始搜索的任何封闭函数的范围，都包含非本地名称，但也包含非全局名称
  • 倒数第二个作用域包含当前模块的全局名称
  • 最外面的作用域（最后搜索）是包含内置名称的名称空间

＃4。似乎是第二个例子的反例。

编辑2

示例5

>>> def fun1():
...     x = 3
...     def fun2():
...         print x
...     return fun2
... 
>>> fun1()()
3

编辑3

正如@Frédéric指出的那样，对与外部作用域中相同名称的变量进行赋值似乎“屏蔽”了外部变量，从而阻止了赋值功能。

因此，示例4的此修改版本有效：

def my_defining_func():
    def mymethod_outer(self):
        return self.y
    class MyClass(object):
        mymethod = mymethod_outer
        y = 3
    return MyClass

my_defining_func()

但是，这不是：

def my_defining_func():
    def mymethod(self):
        return self.y
    class MyClass(object):
        mymethod_temp = mymethod
        mymethod = mymethod_temp
        y = 3
    return MyClass

my_defining_func()

我仍然不完全理解为什么会发生这种屏蔽：在分配发生时，名称绑定是否应该发生？

此示例至少提供了一些提示（以及更有用的错误消息）：

>>> def my_defining_func():
...     x = 3
...     def my_inner_func():
...         x = x
...         return x
...     return my_inner_func
... 
>>> my_defining_func()()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in my_inner_func
UnboundLocalError: local variable 'x' referenced before assignment
>>> my_defining_func()
<function my_inner_func at 0xb755e6f4>

这样看来，局部变量是在函数创建时定义的（成功），导致局部名称被“保留”，从而在调用函数时掩盖了外部作用域的名称。

有趣。

感谢Frédéric的答案！

供参考，来自python docs：

重要的是要认识到范围是由文本确定的：模块中定义的函数的全局范围是该模块的名称空间，无论调用该函数的位置或别名是什么。另一方面，实际的名称搜索是在运行时动态完成的-但是，语言定义正在“编译”时向静态名称解析发展，所以不要依赖动态名称解析！（实际上，局部变量已经是静态确定的。）

编辑4

真正的答案

这种看似令人困惑的行为是由PEP 227中定义的Python的静态嵌套范围引起的。实际上，它与PEP 3104没有关系。

从PEP 227：

名称解析规则通常用于静态范围的语言[...]未声明变量。如果名称绑定操作发生在函数中的任何位置，则该名称将被视为函数的本地名称，并且所有引用都引用本地绑定。如果在绑定名称之前发生引用，则会引发NameError。

[...]

蒂姆·彼得斯（Tim Peters）的一个例子说明了在没有声明的情况下嵌套范围的潜在陷阱：

i = 6
def f(x):
    def g():
        print i
    # ...
    # skip to the next page
    # ...
    for i in x:  # ah, i *is* local to f, so this is what g sees
        pass
    g()

对g（）的调用将引用由for循环绑定到f（）中的变量i。如果在执行循环之前调用g（），则会引发NameError。

让我们运行Tim示例的两个简单版本：

>>> i = 6
>>> def f(x):
...     def g():
...             print i
...     # ...
...     # later
...     # ...
...     i = x
...     g()
... 
>>> f(3)
3

当在其内部范围内g()找不到i时，它将动态向外搜索，找到iinf的范围，该范围已3通过i = x分配绑定。

但是更改最后两个语句的顺序f会导致错误：

>>> i = 6
>>> def f(x):
...     def g():
...             print i
...     # ...
...     # later
...     # ...
...     g()
...     i = x  # Note: I've swapped places
... 
>>> f(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in f
  File "<stdin>", line 3, in g
NameError: free variable 'i' referenced before assignment in enclosing scope

记住PEP 227说过“名称解析规则是静态范围语言的典型代表”，让我们看一下（半）等效的C版本提供的内容：

// nested.c
#include <stdio.h>

int i = 6;
void f(int x){
    int i;  // <--- implicit in the python code above
    void g(){
        printf("%d\n",i);
    }
    g();
    i = x;
    g();
}

int main(void){
    f(3);
}

编译并运行：

$ gcc nested.c -o nested
$ ./nested 
134520820
3

因此，尽管C会很乐意使用一个未绑定的变量（使用之前存储在这里的任何东西：在这种情况下为134520820），但Python（谢天谢地）拒绝了。

作为一个有趣的旁注，静态嵌套范围实现了Alex Martelli所说的“ Python编译器所做的最重要的单个优化：函数的局部变量不保存在dict中，它们存放在紧密的值向量中，并且每个本地变量访问使用该向量中的索引，而不是名称查找。”

python  namespaces  scope 
— 加布里埃尔·格兰特（Gabriel Grant）
source

Answers:

21

这是Python名称解析规则的产物：您只能访问全局和局部作用域，而不能访问它们之间的作用域，例如，不能访问您的直接外部作用域。

编辑：上面的措辞很差，您确实可以访问在外部作用域中定义的变量，但是通过执行操作x = x或mymethod = mymethod从非全局名称空间访问，实际上是用您在本地定义的变量掩盖了外部变量。

在示例2中，您的直接外部作用域是全局作用域，因此MyClass可以看到mymethod，但是在示例4中，您的直接外部作用域是my_defining_func()，所以不能，因为的外部定义mymethod已经被其局部定义掩盖了。

有关非本地名称解析的更多详细信息，请参见PEP 3104。

另请注意，由于上述原因，我无法让示例3在Python 2.6.5或3.1.2下运行：

>>> def myfunc():
...     x = 3
...     class MyClass(object):
...         x = x
...     return MyClass
... 
>>> myfunc().x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in myfunc
  File "<stdin>", line 4, in MyClass
NameError: name 'x' is not defined

但是以下方法会起作用：

>>> def myfunc():
...     x = 3
...     class MyClass(object):
...         y = x
...     return MyClass
... 
>>> myfunc().y
3
— 弗雷德里克·哈米迪（FrédéricHamidi）
source
PEP 3104只适用于Python的3
— 克里斯·摩根
@Chris，是的，并且nonlocal在Python 2中不存在，因此发问者不能使用它。那实际上是我的意思；）
— FrédéricHamidi
根据docs.python.org/tutorial/…：在执行期间的任何时候，至少有三个嵌套作用域可以直接访问其名称空间：•最里面的作用域，首先被搜索，包含本地名称•任何作用域的作用域从最接近的封闭范围开始搜索的封闭函数包含非本地名称，但也包含非全局名称•倒数第二个范围包含当前模块的全局名称•最外面的范围（最后搜索）是包含以下内容的名称空间内置的名字
— 加布里埃尔格兰特
@Gabriel，示例3NameError在2.6.5和3.1.2下都加注。
— 弗雷德里克·哈米迪
1
在教程中，@ Gabrielthe scopes of any enclosing functions可能是指定义这些功能的范围，而不是功能本身。
— 弗雷德里克·哈米迪
7

这篇文章已有几年历史，但是讨论Python范围和静态绑定这一重要问题的文章很少见。但是，示例3对作者存在重大误解，可能会使读者感到困惑。（不要认为其他所有方法都是正确的，只是我只详细看了示例3提出的问题）。让我澄清一下发生了什么。

在示例3中 

def myfunc():
    x = 3
    class MyClass(object):
        x = x
    return MyClass

>>> myfunc().x

必须返回错误，与帖子作者所说的不同。我相信他错过了该错误，因为在示例1中已将其x分配给3全局范围。因此对发生的事情有错误的理解。

这篇文章中广泛描述了该解释， 如何在Python中解析对变量的引用

— 用户名
source
感谢您指出这一点：我已经更新了说明，以纠正您发现的错误
— Gabriel Grant
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.