命名空间是变量名到对象的映射，作用域决定了变量在哪些地方可以被访问。Python使用LEGB规则来确定变量的作用域。

# 全局命名空间
global_var = "我是全局变量"

def my_function():
    # 局部命名空间
    local_var = "我是局部变量"
    print(f"局部变量: {local_var}")
    print(f"全局变量: {global_var}")

my_function()
# print(local_var)  # NameError: name 'local_var' is not defined

LEGB规则

Python使用LEGB规则来确定变量的作用域：

1. Local（局部作用域）
2. Enclosing（嵌套作用域）
3. Global（全局作用域）
4. Built-in（内置作用域）

# 内置作用域
print = "我覆盖了内置的print函数"  # 不推荐！

# 全局作用域
global_var = "全局变量"

def outer_function():
    # 嵌套作用域
    enclosing_var = "嵌套变量"
    
    def inner_function():
        # 局部作用域
        local_var = "局部变量"
        
        # 访问不同作用域的变量
        print(f"局部: {local_var}")
        print(f"嵌套: {enclosing_var}")
        print(f"全局: {global_var}")
        print(f"内置: {len}")  # 内置函数len
    
    inner_function()

outer_function()

作用域详解

1. 局部作用域

def calculate_area(length, width):
    """计算面积"""
    # 这些变量都在局部作用域中
    area = length * width
    perimeter = 2 * (length + width)
    
    def get_info():
        # 嵌套函数可以访问外部函数的变量
        return f"面积: {area}, 周长: {perimeter}"
    
    return get_info()

result = calculate_area(5, 3)
print(result)  # 面积: 15, 周长: 16
# print(area)  # NameError: name 'area' is not defined

2. 全局作用域

# 全局变量
counter = 0

def increment_counter():
    """增加计数器"""
    global counter  # 声明使用全局变量
    counter += 1
    return counter

def get_counter():
    """获取计数器值"""
    return counter  # 可以读取全局变量，无需global声明

print(increment_counter())  # 1
print(increment_counter())  # 2
print(get_counter())        # 2

3. 嵌套作用域（闭包）

def create_multiplier(factor):
    """创建乘法器函数"""
    def multiplier(number):
        # 可以访问外部函数的factor变量
        return number * factor
    return multiplier

# 创建不同的乘法器
double = create_multiplier(2)
triple = create_multiplier(3)

print(double(5))  # 10
print(triple(5))  # 15

# 闭包保持了对外部变量的引用
print(double.__closure__[0].cell_contents)  # 2

常见陷阱

1. 局部变量遮蔽全局变量

x = "全局变量"

def confusing_function():
    print(x)  # 这里会报错！
    x = "局部变量"  # 这行代码让x成为局部变量
    print(x)

# confusing_function()  # UnboundLocalError: local variable 'x' referenced before assignment

2. 修改可变对象

# 列表是可变对象
my_list = [1, 2, 3]

def modify_list():
    my_list.append(4)  # 修改全局列表
    print(f"函数内: {my_list}")

modify_list()
print(f"函数外: {my_list}")  # [1, 2, 3, 4]

# 字符串是不可变对象
my_string = "Hello"

def modify_string():
    my_string += " World"  # 这会创建新的局部变量
    print(f"函数内: {my_string}")

modify_string()
print(f"函数外: {my_string}")  # Hello

高级技巧

1. nonlocal关键字

def outer_function():
    x = "外部函数"
    
    def inner_function():
        nonlocal x  # 修改嵌套作用域的变量
        x = "内部函数修改"
        print(f"内部: {x}")
    
    inner_function()
    print(f"外部: {x}")

outer_function()
# 输出:
# 内部: 内部函数修改
# 外部: 内部函数修改

2. 命名空间字典操作

def inspect_namespace():
    """检查当前命名空间"""
    local_vars = locals()
    global_vars = globals()
    
    print("局部变量:")
    for name, value in local_vars.items():
        if not name.startswith('_'):
            print(f"  {name}: {value}")
    
    print("\n全局变量:")
    for name, value in global_vars.items():
        if not name.startswith('_') and name not in local_vars:
            print(f"  {name}: {value}")

# 测试
test_var = "测试变量"
inspect_namespace()

最佳实践

1. 避免全局变量

# 不好的做法
global_counter = 0

def bad_increment():
    global global_counter
    global_counter += 1

# 好的做法
class Counter:
    def __init__(self):
        self.count = 0
    
    def increment(self):
        self.count += 1
        return self.count

counter = Counter()
print(counter.increment())  # 1

2. 使用函数参数传递数据

# 不好的做法
def process_data():
    global user_data
    return user_data.upper()

# 好的做法
def process_data(data):
    return data.upper()

user_data = "hello"
result = process_data(user_data)

3. 合理使用闭包

def create_validator(min_value, max_value):
    """创建数值验证器"""
    def validate(value):
        if not isinstance(value, (int, float)):
            raise TypeError("值必须是数字")
        if not min_value <= value <= max_value:
            raise ValueError(f"值必须在{min_value}和{max_value}之间")
        return True
    return validate

# 创建不同的验证器
age_validator = create_validator(0, 150)
score_validator = create_validator(0, 100)

print(age_validator(25))    # True
print(score_validator(85))  # True
# print(age_validator(200))  # ValueError

调试技巧

1. 使用vars()检查局部变量

def debug_function(x, y):
    z = x + y
    print("局部变量:", vars())
    return z

debug_function(3, 4)
# 输出: 局部变量: {'x': 3, 'y': 4, 'z': 7}

2. 使用dir()检查命名空间

def check_namespace():
    print("当前命名空间中的名称:")
    for name in dir():
        if not name.startswith('_'):
            print(f"  {name}")

check_namespace()

写在最后

命名空间和作用域是Python内存管理的基础。理解它们不仅有助于写出正确的代码，还能帮助我们：

• 避免变量冲突：合理规划变量的生命周期
• 优化内存使用：及时释放不需要的变量
• 设计更好的API：通过作用域控制接口的可见性
• 调试复杂问题：快速定位变量作用域相关的问题

记住：在Python的世界里，每个变量都有自己的"住址"，理解LEGB规则是成为优秀开发者的基础。