本文最后更新于 67 天前，其中的信息可能已经过时，如有错误请发送邮件到wuxianglongblog@163.com

作用域

在函数中，Python 从命名空间中寻找变量的顺序如下：

local function scope
enclosing scope
global scope
builtin scope

例子：

local 作用域

def foo(a,b):
    c = 1
    d = a + b + c

这里所有的变量都在 local 作用域。

global 作用域

c = 1
def foo(a,b):
    d = a + b + c

这里的 c 就在 global 作用域。

global 关键词

使用 global 关键词可以在 local 作用域中修改 global 作用域的值。

c = 1
def foo():
    global c
    c = 2

print c
foo()
print c

1
2

其作用是将 c 指向 global 中的 c。

如果不加关键词，那么 local 作用域的 c 不会影响 global 作用域中的值：

c = 1
def foo():
    c = 2

print c
foo()
print c

1
1

built-in 作用域

def list_length(a):
    return len(a)

a = [1,2,3]
print list_length(a)

这里函数 len 就是在 built-in 作用域中：

import __builtin__

__builtin__.len

class 中的作用域

Global	MyClass
`var = 0` `MyClass` `access_class`	`var = 1` `access_class`

# global
var = 0

class MyClass(object):
    # class variable
    var = 1

    def access_class_c(self):
        print 'class var:', self.var

    def write_class_c(self):
        MyClass.var = 2
        print 'class var:', self.var

    def access_global_c(self):
        print 'global var:', var

    def write_instance_c(self):
        self.var = 3
        print 'instance var:', self.var

Global	MyClass	obj
`var = 0` `MyClass` [`access_class`] `obj`	`var = 1` `access_class`

obj = MyClass()

查询 self.var 时，由于 obj 不存在 var，所以跳到 MyClass 中：

Global	MyClass	obj
`var = 0` `MyClass` [`access_class` `self`] `obj`	`var = 1` `access_class`

obj.access_class_c()

class var: 1

查询 var 直接跳到 global 作用域：

Global	MyClass	obj
`var = 0` `MyClass` [`access_class` `self`] `obj`	`var = 1` `access_class`

obj.access_global_c()

global var: 0

修改类中的 MyClass.var：

Global	MyClass	obj
`var = 0` `MyClass` [`access_class` `self`] `obj`	`var = 2` `access_class`

obj.write_class_c()

class var: 2

修改实例中的 var 时，会直接在 obj 域中创建一个：

Global	MyClass	obj
`var = 0` `MyClass` [`access_class` `self`] `obj`	`var = 2` `access_class`	`var = 3`

obj.write_instance_c()

instance var: 3

MyClass.var

MyClass 中的 var 并没有改变。

词法作用域

对于嵌套函数：

def outer():
    a = 1
    def inner():
        print "a =", a
    inner()

outer()

a = 1

如果里面的函数没有找到变量，那么会向外一层寻找变量，如果再找不到，则到 global 作用域。

返回的是函数的情况：

def outer():
    a = 1
    def inner():
        return a
    return inner

func = outer()

print 'a (1):', func()

a (1): 1

func() 函数中调用的 a 要从它定义的地方开始寻找，而不是在 func 所在的作用域寻找。

发送评论编辑评论

作用域