掌握 Python 作用域规则的四个核心要点

jinchanchan

在Python编程中，作用域是一个非常重要的概念。它规定了变量可以在哪里使用、以及它的生命周期。如果你对作用域不熟悉，可能会遇到很多让人头疼的问题。今天我们就一起聊聊Python作用域规则的4个核心要点。
　　
  核心要点1：全局作用域
　　我们先从最简单的开始，什么是全局作用域呢？简单来说，就是代码里任何地方都能访问到的变量。
　

1. 　# 定义一个全局变量
   
2. 　   global_variable = "我是一个全局变量"
   
3. 　　def my_function():
   
4. 　　    print(global_variable)  # 在函数内部访问全局变量
   
5. 　　my_function()  # 输出: 我是一个全局变量

复制代码

　　这段代码首先定义了一个全局变量global_variable。之后，在函数my_function()内部访问这个变量并打印出来。可以看到，在函数内直接使用全局变量是没有问题的。

　　核心要点2：局部作用域
　　再来看看局部作用域。局部作用域里的变量只能在它们所在的代码块内（如函数或类）被使用。
　　

1. def local_function():
   
2. 　　    local_variable = "我是局部变量"
   
3. 　　    print(local_variable)
   
4. 　　local_function()  # 输出: 我是局部变量
   
5. 　　print(local_variable)  # 报错！NameError: name 'local_variable' is not defined

复制代码

　　在这里，local_variable是在local_function()内定义的局部变量。当你尝试在函数外访问它时，Python会报错，因为这个变量只存在于它的作用域范围内。

　　核心要点3：LEGB规则
　　Python遵循所谓的LEGB规则，这是用来查找变量名字绑定的地方。这四个字母分别代表什么？
　　·L（Local）：局部作用域
　　· E（Enclosing）：嵌套作用域（闭包）
　　· G（Global）：全局作用域
　　· B（Built-in）：内置作用域
　　举个例子来帮助理解。
　

1. 　x = "global"  # 全局变量
   
2. 　　def outer():
   
3. 　　    x = "enclosing"  # 外层作用域内的局部变量
   
4. 　　   
   
5. 　　    def inner():
   
6. 　　        x = "local"  # 局部变量
   
7. 　　        print(x)
   
8. 　　   
   
9. 　　    inner()
   
10. 　　outer()  # 输出: local

复制代码

　　在这个示例中，inner()函数里面的print(x)会找到最近的作用域中的x变量，这里是inner()自己的“local”。所以最终输出的是local。
　　
     核心要点4：使用global和nonlocal声明改变变量绑定
　　最后一点要讲的就是怎么在一个函数里面更改外部的变量值。
　　(1) 使用global
　　如果想在函数内部修改全局变量，就要用global关键字。
　

1. 　number = 0
   
2. 　　def modify_global():
   
3. 　　    global number
   
4. 　　    number += 1
   
5. 　　modify_global()
   
6. 　　print(number)  # 输出：1

复制代码

　　在这个例子中，函数modify_global利用global关键字使得它可以增加全局变量number的值。

　　(2) 使用nonlocal
　　当在内嵌函数中要修改外层函数中的变量时，可以使用nonlocal关键字。
　　

1. def counter():
   
2. 　　    count = 0  # 外层作用域变量
   
3. 　　    def increment():
   
4. 　　        nonlocal count  # 声明为非本地作用域变量
   
5. 　　        count += 1
   
6. 　　        return count
   
7. 　　    return increment
   
8. 　　increment_counter = counter()
   
9. 　　print(increment_counter())  # 输出: 1
   
10. 　　print(increment_counter())  # 输出: 2

复制代码

　　这个例子展示了一个闭包的应用场景，其中increment()通过nonlocal声明来修改外层函数counter中的变量count。
　　实战案例
　　下面我们结合实际场景来练习下所学的知识点。假设你需要编写一个计算器，用户输入表达式时能识别变量并计算结果。
　

1. 　memory = {}  # 用来保存用户的变量定义
   
2. 　　def evaluate_expression(expr):
   
3. 　　    try:
   
4. 　　        return eval(expr, globals(), memory)
   
5. 　　    except Exception as e:
   
6. 　　        return str(e)
   
7. 　　def calculator():
   
8. 　　    while True:
   
9. 　　        expr = input("Enter an expression (or 'exit' to quit): ")
   
10. 　　        if expr.lower() == 'exit':
    
11. 　　            break
    
12. 　　        
    
13. 　　        result = evaluate_expression(expr)
    
14. 　　        if isinstance(result, float):
    
15. 　　            result = round(result, 4)  # 限制浮点数显示精度
    
16. 　　        
    
17. 　　        print(f"Result: {result}")
    
18. 　　# 运行计算器
    
19. 　　calculator()

复制代码

　　在这个实战案例中，我们创建了一个交互式环境让用户定义他们自己的变量（这些变量存在字典memory中），同时也能进行常规数学运算。比如输入x=5;y=10;x+y将会输出结果15。这里eval()函数允许从一个字符串解析表达式，并根据传入的全局变量字典（这里未传额外）以及存储自定义变量的memory字典执行它。

　总结
　　·本文详细讲解了Python作用域的四个核心要点：
　　· 全局作用域让变量可被任何地方访问。
　　· 局部作用域限定变量仅能在其定义的代码块内有效。
　　· LEGB规则解释变量搜索的顺序：从本地出发逐级向外寻找。
　　· 使用global和nonlocal声明改变变量绑定。

FishC

掌握Python作用域规则的四个核心要点

核心要点1：全局作用域
全局变量在代码的任何位置都可访问：

1. 
   
2. global_var = "我是全局变量"
   
3. def my_func():
   
4.     print(global_var)  # 函数内部访问全局变量
   
5. my_func()  # 输出: 我是全局变量
   

复制代码

核心要点2：局部作用域
局部变量仅在定义它的代码块内有效：

1. 
   
2. def test():
   
3.     local_var = "我是局部变量"
   
4.     print(local_var)  # 正常输出
   
5. test()
   
6. print(local_var)  # 报错：NameError
   

复制代码

核心要点3：LEGB规则
变量查找顺序：Local → Enclosing → Global → Built-in

1. 
   
2. x = "global"
   
3. def outer():
   
4.     x = "enclosing"
   
5.     def inner():
   
6.         x = "local"
   
7.         print(x)  # 输出: local
   
8.     inner()
   
9. outer()
   

复制代码

核心要点4：global与nonlocal声明

• global：修改全局变量
  
  1. 
     
  2. count = 0
     
  3. def update():
     
  4.     global count
     
  5.     count += 1
     
  6. update()
     
  7. print(count)  # 输出: 1
     

  复制代码
  
  
• nonlocal：修改闭包外层变量
  
  1. 
     
  2. def counter():
     
  3.     n = 0
     
  4.     def add():
     
  5.         nonlocal n
     
  6.         n += 1
     
  7.         return n
     
  8.     return add
     
  9. c = counter()
     
  10. print(c(), c())  # 输出: 1 2
      

  复制代码

实战案例：简易计算器
支持变量存储和表达式计算：

1. 
   
2. memory = {}
   
3. def calculate(expr):
   
4.     try:
   
5.         return eval(expr, globals(), memory)
   
6.     except Exception as e:
   
7.         return f"错误: {e}"
   
8. 
   
9. while True:
   
10.     expr = input("输入表达式 (输入exit退出): ")
    
11.     if expr == "exit":
    
12.         break
    
13.     print("结果:", calculate(expr))
    

复制代码

总结

• 全局变量随处可访问，局部变量仅限代码块内
• 变量查找遵循 LEGB 顺序
• 用 global 修改全局变量，用 nonlocal 修改闭包变量
• 实战中可通过 eval() 结合作用域实现动态计算
  

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

快速收敛

不二如是

学习

爬虫121

赞一个，感谢分享