Python 命名空间（Namespace）

在 Python 中，命名空间（Namespace） 是名称（变量、函数、类等）到对象的映射集合，用于管理不同作用域中的标识符访问规则。以下是其核心机制和典型应用：

一、命名空间的类型及生命周期

Python 的命名空间分为三种类型，具有不同的创建和销毁时机：

二、命名空间与作用域的关系

作用域（Scope） 决定了代码中名称的可见性范围，遵循 LEGB 规则（查找顺序）：

1. L (Local)：当前函数内部。
2. E (Enclosing)：外层嵌套函数的命名空间。
3. G (Global)：模块级命名空间。
4. B (Built-in)：内置名称。

示例代码：

x = 10  # 全局命名空间

def outer():
    y = 20  # Enclosing 命名空间
    def inner():
        z = 30  # 局部命名空间
        print(z)     # 访问局部变量 → 30
        print(y)     # 访问 Enclosing 变量 → 20
        print(x)     # 访问全局变量 → 10
        print(len)   # 访问内置函数 → <built-in function len>
    inner()

outer()

三、创建新的命名空间

在 Python 中，创建新的命名空间主要通过以下几种方式实现，每种方式对应不同的场景和需求：

1. 函数调用：自动创建局部命名空间

机制：每次函数被调用时，Python 会自动生成一个局部命名空间，用于存储函数内部的变量。
示例：

def my_func():
    x = 10      # 变量 x 存在于 my_func 的局部命名空间
    print(locals())  # 输出 {'x': 10}

my_func()
# 函数执行结束后，局部命名空间被销毁

2. 类定义：创建类的独立命名空间

机制：类定义时生成一个类命名空间，存储类属性和方法，实例化后对象拥有独立的实例命名空间。
示例：

class MyClass:
    class_var = 100  # 类命名空间中的变量

    def __init__(self):
        self.instance_var = 200  # 对象命名空间中的变量

obj = MyClass()
print(MyClass.class_var)    # 100 (访问类命名空间)
print(obj.instance_var)     # 200 (访问对象命名空间)

3. 手动创建字典：模拟命名空间

机制：使用字典（dict）或 types.SimpleNamespace 手动管理名称映射。
适用场景：动态生成配置、隔离变量作用域。
示例：

# 方式 1：使用字典
ns = {'x': 10, 'y': 20}
ns['z'] = ns['x'] + ns['y']  # 动态添加变量
print(ns)  # {'x': 10, 'y': 20, 'z': 30}

# 方式 2：使用 SimpleNamespace（支持属性访问）
from types import SimpleNamespace
ns = SimpleNamespace(x=10, y=20)
ns.z = ns.x + ns.y
print(ns.z)  # 30

4. 模块导入：全局命名空间隔离

机制：每个 Python 模块（.py 文件）拥有独立的全局命名空间，导入模块时会创建新的命名空间。
示例：

# module1.py
var = "module1"

# module2.py
var = "module2"

# main.py
import module1, module2
print(module1.var)  # "module1"
print(module2.var)  # "module2"

5. 动态执行代码：指定命名空间

机制：通过 exec() 函数执行代码字符串，并指定自定义的命名空间字典。
适用场景：动态生成代码逻辑或隔离执行环境。
示例：

namespace = {}
code = """
x = 10
y = x * 2
"""
exec(code, namespace)  # 在 namespace 字典中执行代码
print(namespace)       # {'x': 10, 'y': 20, '__builtins__': {...}}

6. 元类控制类命名空间

机制：通过自定义元类重写 __prepare__ 方法，定制类命名空间的初始结构。
适用场景：框架开发中自动添加类属性或校验命名规范。
示例：

class CustomNamespaceMeta(type):
    @classmethod
    def __prepare__(cls, name, bases):
        # 返回一个 OrderedDict 以保留类属性定义顺序
        from collections import OrderedDict
        return OrderedDict()

    def __new__(cls, name, bases, attrs):
        attrs['author'] = "Anonymous"  # 自动添加类属性
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=CustomNamespaceMeta):
    version = 1.0

print(MyClass.author)  # "Anonymous"（来自元类注入）

7. 闭包：嵌套函数的命名空间

机制：嵌套函数的外层函数变量会保存在闭包的 __closure__ 属性中，形成独立的命名空间。
示例：

def outer():
    x = 10
    def inner():
        print(x)  # 访问外层函数的命名空间
    return inner

closure = outer()
closure()  # 输出 10
print(closure.__closure__)  # 包含 x 的 cell 对象

选择合适的方式

通过合理选择命名空间创建方式，可以提升代码的可维护性和扩展性，同时避免变量污染和冲突。

四、命名空间的操作与访问

1. 查看当前命名空间：

# 查看全局命名空间（返回字典）
print(globals())

# 查看局部命名空间（函数内使用）
def test():
    a = 1
    print(locals())  # {'a': 1}

2. 跨作用域修改变量：

• global 修改全局变量：

x = 10
def modify_global():
    global x
    x = 20
modify_global()
print(x)  # 20

• nonlocal 修改外层嵌套函数的变量：

def outer():
    y = 10
    def inner():
        nonlocal y
        y = 20
    inner()
    print(y)  # 20
outer()

五、类与对象的命名空间

1. 类的命名空间：

• 类定义中的变量和方法属于类的命名空间。
• 实例化时，对象通过 __dict__ 维护自己的属性。

class MyClass:
    class_var = 100  # 类命名空间
    def __init__(self):
        self.instance_var = 200  # 对象命名空间

obj = MyClass()
print(MyClass.class_var)    # 100
print(obj.instance_var)     # 200

2. 继承链中的名称查找：

class Parent:
    value = "Parent"
class Child(Parent):
    value = "Child"  # 覆盖父类属性
print(Child.value)  # "Child"

六、典型应用场景

1. 避免名称冲突：

# 不同模块的同名全局变量互不影响
# module1.py
x = 100

# module2.py
x = "hello"

2. 闭包与装饰器：

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

c = counter()
print(c())  # 1
print(c())  # 2

七、注意事项

1. 避免滥用全局变量：全局变量易导致代码耦合，优先使用参数传递。
2. 名称遮蔽问题：局部变量可能意外覆盖全局或内置名称。

def risky():
    len = 10      # 遮蔽内置函数 len
    print(len)    # 10（无法再访问内置函数）

1. 动态修改命名空间：谨慎使用 globals().update() 或 setattr()，可能破坏封装性。

总结

合理利用命名空间能有效管理代码的作用域和生命周期，提高可维护性。在复杂项目中，遵循以下原则：

• 最小化全局变量，优先使用局部作用域。
• 使用 global/nonlocal 时明确声明意图。
• 类的设计需清晰区分类属性和实例属性。