1. 概述
在Python编程中，命名空间（Namespace）和作用域（Scope）是两个核心概念，它们决定了变量、函数和类的可见性和生命周期。理解这两个概念对于编写清晰、可维护的Python代码至关重要。
1.1 基本概念
- 命名空间：是一个映射，将名称（如变量名、函数名、类名）映射到对象（如整数、字符串、函数、类）
- 作用域
- 变量查找：当引用一个名称时，Python会按照一定的规则在不同的命名空间中查找该名称
2. 命名空间
2.1 命名空间的定义
命名空间是一个从名称到对象的映射，每个名称都在一个特定的命名空间中唯一存在。不同命名空间中的名称可以相同，而不会发生冲突。
# 不同命名空间中的相同名称不会冲突
deffunc():
x =10# 函数命名空间中的x
print(f"函数中的x: {x}")
x =20# 全局命名空间中的x
func()
print(f"全局中的x: {x}")
2.2 命名空间的类型
Python中有以下几种主要的命名空间类型：
2.2.1 内置命名空间（Built-in Namespace）
内置命名空间包含Python内置的名称，如print()、len()、int()等。它在Python解释器启动时创建，在解释器关闭时销毁。
# 访问内置命名空间中的名称
print("Hello, World!")# print是内置名称
print(len("Python"))# len是内置名称
print(int("123"))# int是内置名称
# 查看内置命名空间中的名称
import builtins
print(dir(builtins))# 列出所有内置名称
2.2.2 全局命名空间（Global Namespace）
全局命名空间包含在模块级别定义的名称。当导入一个模块时，会创建该模块的全局命名空间，直到该模块被卸载时销毁。
# 模块级别定义的名称（全局命名空间）
name ="Zhang San"# 全局变量
defgreet():
print(f"Hello, {name}!")# 访问全局变量
classPerson:
pass# 全局类
# 查看全局命名空间中的名称
print(globals())# 返回全局命名空间的字典表示
2.2.3 局部命名空间（Local Namespace）
局部命名空间包含在函数或方法内部定义的名称。当函数被调用时，会创建该函数的局部命名空间，当函数返回或抛出异常时销毁。
defcalculate(a, b):
# 函数内部定义的名称（局部命名空间）
sum_result = a + b # 局部变量
product_result = a * b # 局部变量
return sum_result, product_result
# 调用函数时创建局部命名空间
result = calculate(5,3)
print(result)
# 查看局部命名空间中的名称（只能在函数内部）
deffunc():
x =10
y =20
print(locals())# 返回局部命名空间的字典表示
func()
2.2.4 嵌套命名空间（Enclosing Namespace）
嵌套命名空间是指嵌套函数中外层函数的命名空间。它在内部函数定义时创建，直到内部函数被销毁时才可能销毁。
defouter():
# 外层函数的命名空间（嵌套命名空间）
outer_var ="Hello from outer"
definner():
# 内层函数可以访问外层函数的变量
print(f"Inner function accessing: {outer_var}")
return inner
# 创建并调用内部函数
inner_func = outer()
inner_func()# 输出: Inner function accessing: Hello from outer
2.3 命名空间的生命周期
不同类型的命名空间有不同的生命周期：
3. 作用域
3.1 作用域的定义
作用域是一个区域，定义了名称在程序中的可见性。Python中的作用域决定了在何处可以访问特定的名称。
3.2 作用域的类型
Python中有以下几种主要的作用域类型：
3.2.1 内置作用域（Built-in Scope）
内置作用域包含内置命名空间中的名称，这些名称在程序的任何地方都可以访问。
# 内置作用域中的名称在任何地方都可访问
print("Hello")# print在内置作用域
ifTrue:
print(len([1,2,3]))# len在内置作用域
deffunc():
print(int("42"))# int在内置作用域
func()
3.2.2 全局作用域（Global Scope）
全局作用域包含模块级别定义的名称，这些名称在模块的任何地方都可以访问，包括模块内部的函数和类。
# 全局作用域
x =10# 全局变量
deffunc1():
print(f"func1中的x: {x}")# 可以访问全局变量
deffunc2():
print(f"func2中的x: {x}")# 可以访问全局变量
classMyClass:
defmethod(self):
print(f"MyClass.method中的x: {x}")# 可以访问全局变量
func1()
func2()
obj = MyClass()
obj.method()
3.2.3 局部作用域（Local Scope）
局部作用域包含函数或方法内部定义的名称，这些名称只能在该函数或方法内部访问。
deffunc():
# 局部作用域
y =20# 局部变量
print(f"func中的y: {y}")
func()
# 尝试在函数外部访问局部变量会引发NameError
try:
print(y)
except NameError as e:
print(f"错误: {e}")
3.2.4 嵌套作用域（Enclosing Scope）
嵌套作用域是指嵌套函数中外层函数的作用域，内部函数可以访问外层函数的名称。
defouter():
# 嵌套作用域
z =30# 外层函数的变量
definner():
print(f"inner中的z: {z}")# 可以访问外层函数的变量
return inner
inner_func = outer()
inner_func()# 可以访问外层函数的变量
# 尝试直接访问外层函数的变量会引发NameError
try:
print(z)
except NameError as e:
print(f"错误: {e}")
4. LEGB规则
Python使用LEGB规则来确定变量的查找顺序。当引用一个名称时，Python会按照以下顺序查找该名称：
- L
- E
- G
- B
如果在所有命名空间中都找不到该名称，则会引发NameError异常。
4.1 LEGB规则示例
# 内置作用域
deffunc():
# 局部作用域
x =10# 局部变量
print(f"局部x: {x}")
x =20# 全局变量
# 变量查找顺序：局部 → 全局 → 内置
func()# 使用局部x (10)
print(f"全局x: {x}")# 使用全局x (20)
# 嵌套函数的LEGB规则
x =100# 全局变量
defouter():
x =200# 外层函数的变量（嵌套作用域）
definner():
x =300# 内层函数的变量（局部作用域）
print(f"inner中的x: {x}")# 查找顺序：L(300) → E(200) → G(100) → B
inner()
print(f"outer中的x: {x}")# 查找顺序：L(200) → G(100) → B
outer()
print(f"全局中的x: {x}")# 查找顺序：G(100) → B
5. 变量的定义和修改
5.1 局部变量的定义
在函数内部定义的变量默认是局部变量，只能在函数内部访问。
deffunc():
x =10# 局部变量
print(f"函数内部: {x}")
func()
# 尝试访问局部变量会引发NameError
try:
print(f"函数外部: {x}")
except NameError as e:
print(f"错误: {e}")
5.2 全局变量的访问
函数内部可以访问全局变量，但不能直接修改全局变量。
x =20# 全局变量
deffunc():
print(f"访问全局变量x: {x}")# 可以访问全局变量
# 尝试修改全局变量会创建一个新的局部变量
x =30# 这是一个新的局部变量，不是修改全局变量
print(f"局部变量x: {x}")
func()
print(f"全局变量x: {x}")# 全局变量x的值仍然是20
5.3 global关键字
使用global关键字可以在函数内部修改全局变量。
x =20# 全局变量
deffunc():
global x # 声明x是全局变量
print(f"访问全局变量x: {x}")# 20
x =30# 修改全局变量
print(f"修改后的全局变量x: {x}")# 30
func()
print(f"函数外部的全局变量x: {x}")# 30
5.4 nonlocal关键字
使用nonlocal关键字可以在嵌套函数内部修改外层函数的变量。
defouter():
x =10# 外层函数的变量
definner():
nonlocal x # 声明x是外层函数的变量
print(f"访问外层函数变量x: {x}")# 10
x =20# 修改外层函数的变量
print(f"修改后的外层函数变量x: {x}")# 20
inner()
print(f"外层函数中的x: {x}")# 20
outer()
6. 闭包
6.1 闭包的定义
闭包（Closure）是一个函数，它记住了其定义环境中的变量，即使该环境已经不存在。闭包通常由嵌套函数实现，内部函数引用了外层函数的变量。
6.2 闭包的条件
一个函数要成为闭包，需要满足以下条件：
6.3 闭包示例
defouter(x):
definner(y):
return x + y # 引用了外层函数的变量x
return inner # 返回内部函数
# 创建闭包
add5 = outer(5)
add10 = outer(10)
# 调用闭包
print(f"5 + 3 = {add5(3)}")# 8
print(f"10 + 7 = {add10(7)}")# 17
# 闭包仍然可以访问外层函数的变量x
print(f"add5的x值: {add5.__closure__[0].cell_contents}")# 5
print(f"add10的x值: {add10.__closure__[0].cell_contents}")# 10
6.4 闭包的应用
闭包常用于：
# 数据隐藏
defmake_counter():
count =0# 私有变量
defcounter():
nonlocal count
count +=1
return count
return counter
# 创建计数器
counter1 = make_counter()
counter2 = make_counter()
print(counter1())# 1
print(counter1())# 2
print(counter2())# 1
print(counter1())# 3
7. 命名空间字典
Python提供了以下内置函数来访问不同的命名空间字典：
locals()globals()vars()：返回对象的命名空间字典（如果没有参数，等同于locals()）
7.1 locals()函数
deffunc(x, y):
z = x + y
print("局部命名空间:",locals())
func(3,5)
# 输出: 局部命名空间: {'x': 3, 'y': 5, 'z': 8}
7.2 globals()函数
x =10
y =20
deffunc():
z =30
print("全局命名空间:",globals()['x'],globals()['y'])
# 注意：不要尝试通过globals()修改全局变量
# 应该使用global关键字
func()
# 输出: 全局命名空间: 10 20
7.3 vars()函数
classMyClass:
def__init__(self, x, y):
self.x = x
self.y = y
obj = MyClass(10,20)
print("对象的命名空间:",vars(obj))
# 输出: 对象的命名空间: {'x': 10, 'y': 20}
# vars()没有参数等同于locals()
deffunc(x, y):
z = x + y
print("局部命名空间:",vars())
func(3,5)
# 输出: 局部命名空间: {'x': 3, 'y': 5, 'z': 8}
8. 常见问题
8.1 变量遮蔽（Variable Shadowing）
当内层作用域中的变量名与外层作用域中的变量名相同时，内层变量会遮蔽外层变量。
x =10# 全局变量
deffunc():
x =20# 局部变量，遮蔽了全局变量x
print(f"函数内部: {x}")# 使用局部变量x
func()
print(f"全局变量: {x}")# 全局变量x仍然是10
8.2 未定义变量
如果在当前作用域中定义变量之前就引用它，会引发UnboundLocalError异常。
x =10# 全局变量
deffunc():
print(f"访问x: {x}")# 尝试在定义前访问x
x =20# 局部变量x的定义
# 会引发UnboundLocalError
try:
func()
except UnboundLocalError as e:
print(f"错误: {e}")
8.3 可变对象与不可变对象
当闭包引用可变对象时，可以直接修改该对象，无需使用nonlocal关键字。
defouter():
# 可变对象（列表）
items =[]
definner(item):
items.append(item)# 直接修改可变对象
return items
return inner
# 创建闭包
add_item = outer()
print(add_item(1))# [1]
print(add_item(2))# [1, 2]
print(add_item(3))# [1, 2, 3]
9. global和nonlocal关键字
9.1 global关键字
global关键字用于在函数内部声明一个变量是全局变量，可以修改全局变量的值。
count =0# 全局变量
defincrement():
global count # 声明count是全局变量
count +=1
return count
print(increment())# 1
print(increment())# 2
print(count)# 2
9.2 nonlocal关键字
nonlocal关键字用于在嵌套函数内部声明一个变量是外层函数的变量，可以修改外层函数变量的值。
defouter():
x =10# 外层函数的变量
definner():
nonlocal x # 声明x是外层函数的变量
x +=5
return x
return inner
add5 = outer()
print(add5())# 15
print(add5())# 20
9.3 global和nonlocal的区别
10. 作用域的高级用法
10.1 模块级别的__name__变量
__name__是一个特殊的变量，它在模块级别定义，用于标识模块的名称。
# 模块级别
print(f"模块名: {__name__}")# 输出: __main__（如果直接运行该模块）
# 在函数中访问__name__
deffunc():
print(f"函数中的__name__: {__name__}")
func()
10.2 类的命名空间
每个类都有自己的命名空间，类的属性和方法存储在类的命名空间中。
classMyClass:
x =10# 类属性
defmethod(self):
y =20# 实例方法的局部变量
print(f"方法中的y: {y}")
# 访问类的命名空间
print(f"类的命名空间: {MyClass.__dict__}")
print(f"类属性x: {MyClass.x}")
# 创建实例
obj = MyClass()
obj.method()
print(f"实例的命名空间: {obj.__dict__}")
10.3 动态添加变量
可以通过命名空间字典动态添加变量。
deffunc():
locals()['x']=10# 动态添加局部变量
print(f"动态添加的x: {x}")
func()
# 动态添加全局变量
globals()['y']=20
print(f"动态添加的y: {y}")
11. 最佳实践
11.1 变量命名
11.2 作用域的使用
11.3 避免变量遮蔽
11.4 代码组织
12. 总结
命名空间和作用域是Python编程中的核心概念，它们决定了变量、函数和类的可见性和生命周期。
12.1 关键要点
- 命名空间：是一个从名称到对象的映射，有内置、全局、局部和嵌套四种类型
- 作用域：是一个区域，定义了名称的可见性，有内置、全局、局部和嵌套四种类型
- LEGB规则：变量查找顺序为局部 → 嵌套 → 全局 → 内置
- global关键字
- nonlocal关键字
- 闭包
- 命名空间字典：可以通过locals()、globals()和vars()函数访问
12.2 实践建议
- 只有在必要时才使用global和nonlocal关键字
通过掌握这些概念和最佳实践，可以编写更加清晰、可维护的Python代码，避免常见的命名和作用域问题。
发布网站：荣殿教程（zhangrongdian.com）
作者：张荣殿
10个月宝宝每天需要喝多少奶粉？
