该消息包含很多示例，时间有点长，但是我希望它能帮助我和其他人更好地掌握Python 2.7中变量和属性查找的全部内容。

我正在将PEP
227（http://www.python.org/dev/peps/pep-0227/）的术语用于代码块（例如模块，类定义，函数定义等）和变量绑定（例如作为赋值，参数声明，类和函数声明，for循环等）

我将术语变量用于可以不带点号调用的名称，将属性用于需要使用对象名称进行限定的名称（例如obj.x用于对象obj的属性x）。

Python中所有代码块都有三个作用域，但有以下功能：

• 本地
• 全球
• 内建

Python中只有四个功能块（根据PEP 227）：

• 本地
• 封闭功能
• 全球
• 内建

将变量绑定到块中并找到它的规则非常简单：

• 变量与块中对象的任何绑定都使该变量在此块中成为局部变量，除非将该变量声明为全局变量（在这种情况下，该变量属于全局范围）
• 对于所有块，使用规则LGB（本地，全局，内置）查找对变量的引用，但函数
• 仅使用LEGB规则（局部，封闭，全局，内置）查找对变量的引用。

让我知道一些验证此规则的示例，并显示了许多特殊情况。对于每个示例，我都会给出自己的理解。如果我错了，请纠正我。对于最后一个示例，我不了解结果。

范例1：

x = "x in module"
class A():
    print "A: "  + x                    #x in module
    x = "x in class A"
    print locals()
    class B():
        print "B: " + x                 #x in module
        x = "x in class B"
        print locals()
        def f(self):
            print "f: " + x             #x in module
            self.x = "self.x in f"
            print x, self.x
            print locals()

>>>A.B().f()
A: x in module
{'x': 'x in class A', '__module__': '__main__'}
B: x in module
{'x': 'x in class B', '__module__': '__main__'}
f: x in module
x in module self.x in f
{'self': <__main__.B instance at 0x00000000026FC9C8>}

类没有嵌套作用域（规则LGB），并且如果不使用限定名称（在此示例中为self.x），则类中的函数无法访问类的属性。在PEP227中对此进行了很好的描述。

范例2：

z = "z in module"
def f():
    z = "z in f()"
    class C():
        z = "z in C"
        def g(self):
            print z
            print C.z
    C().g()
f()
>>> 
z in f()
z in C

这里使用LEGB规则查找函数中的变量，但是如果路径中有类，则将跳过类参数。同样，这就是PEP 227的解释。

范例3：

var = 0
def func():
    print var
    var = 1
>>> func()

Traceback (most recent call last):
  File "<pyshell#102>", line 1, in <module>
func()
  File "C:/Users/aa/Desktop/test2.py", line 25, in func
print var
UnboundLocalError: local variable 'var' referenced before assignment

我们期望使用诸如python这样的动态语言来动态地解决所有问题。但这不是函数的情况。局部变量在编译时确定。PEP 227和
http://docs.python.org/2.7/reference/executionmodel.html以这种方式描述此行为

“如果名称绑定操作发生在代码块内的任何地方，则该块内对该名称的所有使用都将视为对当前块的引用。”

示例4：

x = "x in module"
class A():
    print "A: " + x
    x = "x in A"
    print "A: " + x
    print locals()
    del x
    print locals()
    print "A: " + x
>>> 
A: x in module
A: x in A
{'x': 'x in A', '__module__': '__main__'}
{'__module__': '__main__'}
A: x in module

但是我们在这里看到PEP227中的此语句“如果在代码块内的任何地方发生名称绑定操作，则该块内对该名称的所有使用都将视为对当前块的引用。”
当代码块是一个类时是错误的。而且，对于类来说，本地名称绑定似乎不是在编译时进行的，而是在执行期间使用类名称空间进行的。在这方面，PEP227和Python文档中的执行模型具有误导性，并且在某些方面是错误的。

范例5：

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            x = x
            print x
        return MyClass
    myfunc()
f2()
>>> 
x in module

我对这段代码的理解如下。指令x =
x首先查找表达式右手x所指的对象。在这种情况下，将在类中本地查找该对象，然后按照LGB规则在全局范围中查找该对象，即字符串’x in
module’。然后，在类字典中创建MyClass的局部属性x，并指向字符串对象。

范例6：

现在这是一个我无法解释的例子。它与示例5非常接近，我只是将本地MyClass属性从x更改为y。

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            y = x
            print y
        return MyClass
    myfunc()
f2()
>>>
x in myfunc

在那种情况下，为什么要在最里面的函数中查找MyClass中的x引用？