一文详解Python的变量作用域

 更新时间:2026年06月12日 08:29:12   作者:傻啦嘿哟  
这篇文章主要介绍了Python中的变量作用域问题,通过具体例子说明了局部、全局、嵌套和内置作用域的概念,以及如何正确修改全局变量,理解这些概念有助于避免常见的编程错误,需要的朋友可以参考下

一个让我调试了2小时的bug

去年有个朋友发给我一段代码,让我帮忙看看问题出在哪。

他写了一个小程序,用来统计用户输入的数字:

total = 0
def process_numbers():
    while True:
        num = input("请输入数字(输入q退出):")
        if num == 'q':
            break
        total = total + int(num)
        print(f"当前总和:{total}")
process_numbers()
print(f"最终总和:{total}")

运行结果:

请输入数字(输入q退出):5
UnboundLocalError: local variable 'total' referenced before assignment

他懵了。total明明在函数外面定义好了,为什么报错说没定义?

他试了另一个写法:

count = 10
def show():
    print(count)
show()  # 输出10,正常运行

奇怪,这个就能读到。为什么一个能读,一个不能改?

那天晚上,我花了一个小时给他讲清楚什么是变量作用域。今天我把这些内容整理出来,希望帮你绕开同样的坑。

什么是作用域?一个快递站的比喻

先别急着看代码,我们来想一个生活中的场景。

你家住在一个小区。小区里有三个地方可以收快递:

  • 你家门口:只有你能拿,邻居拿不到
  • 小区快递柜:整个小区的业主都能用
  • 城市物流中心:全市都能用

变量作用域也是类似的概念。Python里的变量也分“放在哪”:

  • 局部变量:只属于当前函数,外面访问不到
  • 嵌套作用域:外层函数里的变量,内层函数可以访问
  • 全局变量:整个文件都能访问
  • 内置作用域:Python自带的,任何时候都能用

这就是著名的LEGB规则:Local → Enclosing → Global → Built-in。

别被这四个英文词吓到。用一个例子就能说清楚。

第一层:局部作用域(Local)

先看这段代码:

def greet():
    message = "你好"
    print(message)
greet()  # 输出:你好
print(message)  # 报错!NameError: name 'message' is not defined

message是在greet函数内部创建的,它只属于这个函数。函数执行完后,message就消失了。外面的代码看不到它。

这就是局部变量:函数内部定义的变量,外面访问不到。

反过来也一样:

name = "张三"
def say():
    age = 18
    print(name)  # 能读到外面的name
    print(age)   # 能读到自己的age
say()
print(age)  # 报错!外面读不到函数里的age

简单总结:函数里面能看到外面,外面看不到里面

就像一个房间:里面的人能看到窗外的街景,但街上的人看不到房间里放了什么。

第二层:全局作用域(Global)

全局变量定义在函数外面,整个文件里的代码都能访问它。

# 全局变量
app_name = "我的应用"
version = "1.0"
def show_info():
    print(app_name)  # 函数里可以读全局变量
    print(version)
show_info()  # 正常运行
print(app_name)  # 外面也能用

看起来很简单对吧?但坑马上就来了。

函数里可以读全局变量,但不能直接改

counter = 0
def increment():
    counter = counter + 1  # 报错!
increment()

为什么读可以,改不行?

因为当Python看到函数里有counter = xxx这种赋值语句时,它的第一反应是:“哦,你要在函数里创建一个新的局部变量,名字叫counter。”

然后它看到等号右边也有counter,就去局部作用域找这个新变量——还没创建完呢,怎么找得到?于是报错。

解决方法:明确告诉Python,“我要用的是外面的那个counter”。

counter = 0
def increment():
    global counter  # 声明:这个counter是全局的
    counter = counter + 1
increment()
print(counter)  # 1

global就像一把钥匙,让你走进全局变量的房间去修改它。

第三层:嵌套作用域(Enclosing)

函数里面还可以定义函数。这种嵌套函数里,就能访问外层函数的变量。

def outer():
    x = 10  # 外层函数的变量
    def inner():
        print(x)  # 内层函数可以读外层变量
    inner()
outer()  # 输出10

这就叫嵌套作用域(也叫闭包作用域)。inner函数可以访问outer函数里的x

但如果inner想修改x呢?

def outer():
    x = 10
    def inner():
        x = 20  # 这是在inner里创建了一个新的局部变量x
        print("inner里的x:", x)
    inner()
    print("outer里的x:", x)
outer()
# 输出:
# inner里的x: 20
# outer里的x: 10

和外层函数修改全局变量一样,默认情况下,内层函数对变量的赋值只会创建局部变量,不会影响外层函数的变量。

要修改外层函数的变量,需要用nonlocal

def outer():
    x = 10
    def inner():
        nonlocal x  # 声明:这个x来自外层函数
        x = 20
    inner()
    print(x)  # 20
outer()

nonlocalglobal很像,但nonlocal找的是外层函数的变量,不是全局变量。

第四层:内置作用域(Built-in)

这是Python自带的作用域,任何时候都能用。

print(len("hello"))  # len是内置函数
print(sum([1,2,3]))  # sum是内置函数
print(str(100))      # str是内置类型

你不需要导入任何东西就能用它们。

但有一个需要注意的地方:不要用内置函数的名字做变量名

len = 10  # 你定义了一个叫len的变量
print(len("hello"))  # 报错!因为len现在是10,不是函数了

这就叫“覆盖了内置作用域”。修复也很简单:换个变量名,或者删掉这个变量。

一张图看懂LEGB查找顺序

当你在代码里写一个变量名时,Python按这个顺序去找:

  1. Local:当前函数内部
  2. Enclosing:外层函数(如果有嵌套)
  3. Global:模块全局
  4. Built-in:Python内置

找到第一个匹配的就停下,找不到就报NameError

看个综合例子:

x = "global x"  # 全局
def outer():
    x = "outer x"  # 外层函数
    def inner():
        x = "inner x"  # 局部
        print(x)
    inner()
outer()  # 输出 "inner x"

如果注释掉inner里的x = "inner x"

def outer():
    x = "outer x"
    def inner():
        print(x)  # 没有局部x,就去外层找
    inner()
outer()  # 输出 "outer x"

再把outer里的x注释掉:

x = "global x"
def outer():
    def inner():
        print(x)  # 局部没有,外层没有,就去全局找
    inner()
outer()  # 输出 "global x"

最后,如果你定义了一个叫print的变量,Python也不会去找内置的print了:

print = "hello"
print("world")  # 报错,因为print现在是字符串,不能当函数调用

为什么要有作用域?直接全部用全局不好吗?

你可能觉得:作用域这么多层,好麻烦,为什么不把所有变量都设为全局?

答案很简单:混乱

想象一个5000行的文件,100个函数共享100个全局变量。你在修改一个函数时,根本不知道这个变量还在哪里被改过。改一处,崩十处。

作用域就是隔离区。每个函数有自己的小房间,房间里的变量只属于自己。这样你可以放心地写itempx这些名字,不用担心和别的函数冲突。

作用域也是一种文档。看到globalnonlocal,你就知道:“这个变量是共享的,改动它可能会影响其他地方。”

四个最容易踩的坑

坑1:以为if/for能创造作用域

if True:
    x = 10
print(x)  # 10,x还在!
for i in range(5):
    pass
print(i)  # 4,i还在!

很多语言里,iffor里的变量只在代码块内有效。Python不是。Python只有函数能创造新作用域,ifforwhilewith都不能。

坑2:在函数内意外创建局部变量

name = "张三"
def change():
    name = "李四"  # 这不是修改全局,是创建局部
    print("函数内:", name)
change()  # 函数内: 李四
print("全局:", name)  # 全局: 张三 —— 没变!

想改全局变量但忘记写global,Python不会报错,而是默默创建一个局部变量。这种“静默失败”比报错更难找。

坑3:在列表推导式里用变量

x = 10
squares = [x**2 for x in range(5)]
print(x)  # Python 3里还是10,Python 2里会变成4

Python 3修复了这个问题:列表推导式的变量不会泄漏到外部。但如果你用的是Python 2,就要小心。

坑4:在嵌套函数里用循环变量

funcs = []
for i in range(3):
    funcs.append(lambda: i)
for f in funcs:
    print(f())  # 2 2 2,不是0 1 2

所有lambda函数都记住了同一个i的最终值(2)。要解决这个问题,可以把i作为默认参数传进去:

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)  # 把当前i的值固定下来
for f in funcs:
    print(f())  # 0 1 2

实战:三个函数让你彻底明白

写三个简单的函数,涵盖了LEGB的所有情况。

函数1:只读

config = "production"
def get_env():
    return config  # 读全局,不需要global
print(get_env())  # production

函数2:修改

mode = "read"
def switch_to_write():
    global mode
    mode = "write"
switch_to_write()
print(mode)  # write

函数3:嵌套

def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment
counter = make_counter()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

最后一个例子展示了一个重要模式:闭包increment函数“记住”了count变量,即使make_counter已经执行完了,count也没有消失。

快速判断一个变量的作用域

给你一个简单的判断方法:

这个变量在函数内有没有被赋值?

  • 没有 → 去外层/全局找
  • 有 → 它是局部变量(除非你用globalnonlocal声明了)

如果它是局部变量,赋值之前能不能用到它?

  • 不能 → 会报UnboundLocalError

记住这两条,90%的作用域问题都能解决。

一张表总结

场景写法关键字查找范围
函数内读变量直接写局部→嵌套→全局→内置
函数内修改全局变量global x; x = 10global全局
嵌套函数修改外层变量nonlocal x; x = 10nonlocal外层函数
读取内置函数直接用内置命名空间

回到开头的那个bug。我朋友的问题出在哪?

total = 0
def process_numbers():
    # 这里少了一行
    while True:
        num = input("请输入数字:")
        if num == 'q':
            break
        total = total + int(num)  # total被赋值,被视为局部变量

total = total + 1这个语句让Python把total当作局部变量。但局部变量total在赋值前就被用到了,所以报错。

修复方法就是在函数开头加上:

def process_numbers():
    global total
    # 剩下的代码不变

加上这一行之后,total就不再是局部变量了,而是指向全局的那个total

我朋友后来把代码改好了,还学会了用globalnonlocal。从那以后,他再也没被作用域的问题困住过。

以上就是一文详解Python的变量作用域的详细内容,更多关于Python变量作用域的资料请关注脚本之家其它相关文章!

相关文章

  • Python实现Socket通信建立TCP反向连接

    Python实现Socket通信建立TCP反向连接

    本文将记录学习基于 Socket 通信机制建立 TCP 反向连接,借助 Python 脚本实现主机远程控制的目的。感兴趣的可以了解一下
    2021-08-08
  • Python轻量级Web框架之Flask用法详解

    Python轻量级Web框架之Flask用法详解

    Flask是一个用Python编写的轻量级Web应用框架,由于其“微”性质,Flask在提供核心服务的同时,仍然提供了许多扩展的可能性,在这篇文章中,我们将从最基础开始,学习如何使用Flask构建一个Web应用,需要的朋友可以参考下
    2023-08-08
  • Python获取系统所有进程PID及进程名称的方法示例

    Python获取系统所有进程PID及进程名称的方法示例

    这篇文章主要介绍了Python获取系统所有进程PID及进程名称的方法,涉及Python使用psutil对系统进程进行操作的相关实现技巧,需要的朋友可以参考下
    2018-05-05
  • python dict转换成json格式的实现

    python dict转换成json格式的实现

    本文主要介绍了python dict转换成json格式的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2025-03-03
  • pydev使用wxpython找不到路径的解决方法

    pydev使用wxpython找不到路径的解决方法

    pydev使用wx库开发的过程中,import时碰到wx可以识别,但是其它很多函数和变量上面全部是红叉,即无法识别
    2013-02-02
  • Python使用wxPython写一个MD5文件查重清理工具

    Python使用wxPython写一个MD5文件查重清理工具

    电脑用久之后,经常会出现大量重复文件,本文介绍了一个基于Python的本地文件查重工具,支持文件查重、预览、删除等功能,感兴趣的小伙伴可以了解下
    2026-06-06
  •  Python 代码制作动态鞭炮

     Python 代码制作动态鞭炮

    这篇文章主要介绍了 Python 代码制作动态鞭炮,将一个录制好的鞭炮视频以字符画的形式复现,基本步骤是帧采样 → 逐帧转换为字符画 → 字符画合成视频,下面来看看具体的实现步骤吧,需要的小伙伴可以参考一下
    2022-01-01
  • 基于python开发文件常见处理工具

    基于python开发文件常见处理工具

    这篇文章主要为大家详细介绍了如何使用python开发一个文件处理工具,包含文件读写,后缀获取,压缩和解压,文件夹遍历等操作,需要的可以了解下
    2025-06-06
  • python scrapy框架中Request对象和Response对象的介绍

    python scrapy框架中Request对象和Response对象的介绍

    本文介绍了python基础之scrapy框架中Request对象和Response对象的介绍,Request对象主要是用来请求数据,爬取一页的数据重新发送一个请求的时候调用,Response对象一般是由scrapy给你自动构建的,因此开发者不需要关心如何创建Response对象,下面来一起来了解更多内容吧
    2022-02-02
  • 基于Python3 逗号代码 和 字符图网格(详谈)

    基于Python3 逗号代码 和 字符图网格(详谈)

    下面小编就为大家带来一篇基于Python3 逗号代码 和 字符图网格(详谈)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-06-06

最新评论