当前位置:

首页 > 编程开发 > Python中的全局空间和局部空间是什么?

Python中的全局空间和局部空间是什么?

一、空间和局部空间1、命名空间命名空间的概念的提出是为了划分和控制变量是否可见,以及生存周期的长短;命名空间的作用范围叫做作用域。划分一块区域保存所有数据,以字典的方式存储(变量与值形成映射关系)。一共三种。内建命名空间:解释器启动时创建,直到解释器运行结束,生存周期最长;全局命名空间:文件运行时创建,直到解释器运行结束,生存周期较长;局部命名空间:数调用时,里面的局部变量才创建,调用结束后即释放,生存周期较短;创建和销毁顺序创建顺序:python解释器启动->创建内建命名空间->创建全局命名空间->创建

本文目录

      一、空间和局部空间

      1、命名空间

      命名空间的概念的提出是为了划分和控制变量是否可见,以及生存周期的长短;命名空间的作用范围叫做作用域。
      划分一块区域保存所有数据,以字典的方式存储(变量与值形成映射关系)。一共三种。

      内建命名空间:
      解释器启动时创建,直到解释器运行结束,生存周期最长;
      全局命名空间:
      文件运行时创建,直到解释器运行结束,生存周期较长;
      局部命名空间:
      数调用时,里面的局部变量才创建,调用结束后即释放,生存周期较短;
      创建和销毁顺序
      创建顺序:
      python解释器启动->创建内建命名空间->创建全局命名空间->创建局部命名空间
      销毁顺序:
      函数调用结束后->销毁函数对应的局部命名空间数据->销毁全局命名空间数据->销毁内建命名空间数据

      2、全局变量和局部变量

      什么是全局和局部变量:

      局部变量就是在函数内部定义的变量,局部变量所在的就是局部命名空间,作用域仅仅在函数内部可见,也就是说只能在函数内部使用。

      # 在函数中创建的变量就是局部变量
      def func():
         var = '局部变量'
      
      # 局部变量不可以在非对应局部环境中使用
      print(var)  # error, 该变量不存在

      全局变量就是在函数外部定义的或者使用global在函数内部定义的变量,全局变量所在的命名空间就是全局命名空间,作用域横跨整个文件,就是说在整个文件中的任何一个地方都可以使用全局变量。

      # 在全局环境中创建的变量就是全局变量
      var = '全局变量'
      
      def func():
          # 在局部中也可以使用全局变量
          print(var)  # 全局变量
      
      func()

      局部变量最好不要和全局变量同名,如果同名,在局部环境中就无法使用全局变量了。

      var = '全局变量'
      
      def func():
          # 先使用了全局变量
          print(var)  # error, 找不到该变量
              # 然后局部变量和全局变量同名,那么新的局部变量就会在局部空间中覆盖了全局变量的一切影响力,这就叫做局部变量修改了全局变量;
          # 这样的话导致在局部空间中无法在使用该全局变量,之前在局部空间中使用的该变量就成为了先调用后定义;导致出错。
          var = '局部变量'
          print(var)
      
      func()
      
      # 但是局部同名变量不会影响到全局变量的值
      print(var)  # 全局变量

      内置函数就是内建命名空间,指的是那些python中自带的、内置的函数。

      3、作用域

      局部变量作用域:在函数的内部
      全局变量作用域:横跨整个文件

      4、生命周期

      内置变量 -> 全局变量 -> 局部变量
      内置变量自python程序运行的时候开始,一直等到python程序结束之后才会释放;
      全局变量自创建开始,一直到程序结束或者被清除才会释放;
      局部变量字创建开始,一直到局部空间执行结束或者清除就会释放;

      5、全局部函数和关键字的使用

      函数

      Python中的全局空间和局部空间是什么?

      globals()

      返回所有的全局作用域中的内容。
      如果在全局,调用globals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域;

      # 定义一些全局变量
      a, b, c = 1, 2, 3
      
      # 调用globals函数
      res = globals()
      
      # 第一次打印,包含a b c
      print(res)
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002DBDCA5D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}}
      '''
      
      
      # 再定义一些变量
      d, e, f = 1, 2, 3
      
      # 第二次打印,包含a b c d e f
      print(res)
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002DBDCA5D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}, 'd': 1, 'e': 2, 'f': 3}
      '''

      如果在局部,调用globals之后,获取的是调用之前的所用变量,返回字典,全局空间作用域;

      # 定义一些全局变量
      a, b, c = 1, 2, 3
      
      
      # 在局部环境中使用globals函数
      def func():
          res = globals()
          print(res)
      
      
      # 调用函数
      func()
      '''
      结果:不包含 d e f
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001E7C287D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'func': }
      '''
      
      
      # 再定义一些全局变量
      d, e, f = 4, 5, 6
      
      # 第二次调用函数
      func()
      '''
      结果:包含 d e f
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021A3F3DD198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'func': , 'd': 4, 'e': 5, 'f': 6}
      '''

      globals可以动态创建全局变量

      dic = globals()
      
      print(dic)  # 返回系统的字典
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000026F357ED198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'dic': {...}}
      '''
      
      
      # 在全局的字典当中,通过添加键值对,自动创建全局变量,对应的键是变量名,对应的值是变量指向的值
      dic['msr123123123'] = '123456'
      
      print(msr123123123) # 123456
      
      # 查看全局内容
      print(dic)
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000161D944D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'dic': {...}, 'msr123123123': '123456'}
      '''

      locals()

      返回当前所在作用域的所有内容。
      如果在全局,调用locals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域;

      # 定义一些全局变量
      a, b, c = 1, 2, 3
      
      # 调用locals函数
      res = locals()
      
      # 第一次打印,包含a b c
      print(res)
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000018C82A3D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test1.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}}
      '''
      
      
      # 再定义一些变量
      d, e, f = 1, 2, 3
      
      # 第二次打印,包含a b c d e f
      print(res)
      '''
      结果:
      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000018C82A3D198>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/0-project/python/mymsr/ceshi/test1.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}, 'd': 1, 'e': 2, 'f': 3}
      '''

      如果在局部,调用locals之后,获取的是调用之前的所有变量,返回字典,局部空间作用域;

      # 定义一些局部变量
      def func():
         # 局部变量
         aa, bb, cc = 11, 22, 33
      
         # 第一遍调用
         res = locals()
      
         # 第一次打印,包含 aa bb cc
         print(res)  # {'cc': 33, 'bb': 22, 'aa': 11}
      
         # 再定义一些局部变量
         dd, ee, ff = 44, 55, 66
      
         # 第二次打印,不包含 dd ee ff
         print(res)  # {'cc': 33, 'bb': 22, 'aa': 11}
      
         # 调用第二遍
         res2 = locals()
      
         # 打印第一次的调用,包含 dd ee ff
         print(res)  # {'cc': 33, 'bb': 22, 'aa': 11, 'ff': 66, 'ee': 55, 'dd': 44, 'res': {...}}
         
         # 打印第二次的调用,包含 dd ee ff
         print(res2) # {'cc': 33, 'bb': 22, 'aa': 11, 'ff': 66, 'ee': 55, 'dd': 44, 'res': {...}}
      
      # 调用函数,返回在函数中的局部变量
      func()

      关键字

      Python中的全局空间和局部空间是什么?

      global

      在局部环境中创建的变量是局部变量,在全局环境中是不可以使用的。但是使用global定义的变量就是一个全局变量,这个变量可以全局环境中使用。

      def func():
          var = '局部变量'
      
          global glvar
          glvar = '全局变量'
      
      # 一定要执行局部环境哟
      func()
      
      # 全局环境中
      print(var)  # error,局部变量不能调用
      # 使用global定义的变量是全局变量
      print(glvar)    # 全局变量

      在局部环境中无法修改全局变量的值,使用global可以在局部环境中修改全局变量。

      var = '全局变量'
      
      def func():
          global var
          var = '局部环境中修改'
      
      func()
      
      print(var)  # 局部环境中修改

      6、函数的嵌套

      在学习nonlocal之前我们需要先学习一些关于函数嵌套的知识。

      内函数和外函数

      函数之间是可以互相嵌套的,外层的叫做外函数,内层的叫做内函数。

      def outer():
          print('我叫outer,是外函数')
      
          def inner():
              print('我叫inner,在outer的里面,是内函数')
      
          # 在外函数中执行内函数
          inner()
      
      
      # 执行外函数
      outer()
      
      '''
      结果:
      我叫outer,是外函数
      我叫inner,在outer的里面,是内函数
      '''
      • 内函数不可以直接在外函数外执行调用

      • 调用外函数后,内函数也不可以在函数外部调用

      • 内函数只可以在外函数的内部调用

      • 内函数在外函数内部调用时,有先后顺序,必须先定义在调用,因为python没有预读机制,这个预读机制适用于python中的所有场景。

      # 外层是outer,内层是inner,最里层是smaller,调用smaller里的所有代码
      def outer():
          print('我叫outer,是最外层函数,是inner和smaller的外函数')
      
          def inner():
              print('我叫inner,是outer的内函数,是smaller的外函数')
      
              def smaller():
                  print('我叫smaller,是outer和inner的内函数')
      
              # 先在inner中执行smaller
              smaller()
      
          # 然后在outer中执行inner
          inner()
      
      # 最后再执行outer才能执行smaller函数
      outer()
      
      '''
      结果:
      我叫outer,是最外层函数,是inner和smaller的外函数
      我叫inner,是outer的内函数,是smaller的外函数
      我叫smaller,是outer和inner的内函数
      '''

      我们在多个函数嵌套的时候要注意,不管外函数还是内函数,都是函数,只要是函数中的变量都是局部变量。
      内涵可以使用外函数的局部变量,外函数不能直接使用内函数的局部变量。

      二、LEGB原则

      LEGB原则就是一个就近找变量原则,依据就近原则,从下往上,从里向外,依次寻找。

      B————Builtin(Python):Python内置模块的命名空间    (内建作用域)
      G————Global(module):函数外部所在的命名空间        (全局作用域)
      E————Enclosing Function Locals:外部嵌套函数的作用域(嵌套作用域)
      L————Local(Function):当前函数内的作用域           (局部作用域)

      Python中的全局空间和局部空间是什么?

      nonlocal

      现在我们正式学习nonlocal关键字,nonlocal的作用是修改当前局部环境中上一层的局部变量。那么我们根据这个作用便知道了nonlocal的使用环境至少是一个二级的嵌套环境,且外层的局部环境中必须存在一个局部变量。

      def outer():
          # 定义变量
          lvar = 'outer var'
      
          def inner():
              # 内函数使用nonlocal修改上一层的局部变量
              nonlocal lvar
              lvar = 'inner var'
      
          # 执行inner函数
          inner()
          print(lvar)
      
      outer() # inner var

      假如上一层的局部环境中没有这个变量怎么办,那么就根据LEGB原则向上寻找。

      def outer():
          # 定义变量
          lvar = 'outer var'
      
          def inner():
              
              def smaller():
                  
                  # smaller中修改变量,但是inner中没有,就向上寻找修改outer中的变量
                  nonlocal lvar
                  lvar = 'smaller var'
      
              # 执行 smaller函数
              smaller()
      
          # 执行inner函数
          inner()
          print(lvar)
      
      # 执行outer函数
      outer()

      如果层层寻找,直到最外层的函数中也没有这个变量,那么就会报错,因为nonlocal只会修改局部变量,如果超出范围,就会报错。

      var = 1  # 变量在最外层的函数之外,也就是全局变量,nonlocal无法修改
      
      def outer():
      
         def inner():
      
            def smaller():
      
               nonlocal var    # error,没有局部变量
               var = 2
               print(var)
      
            smaller()
      
         inner()
      
      outer()

      三、总结

      全局变量和局部变量

      局部环境中可以调用全局变量,但是不能修改(但是如果全局变量是可变数据则可以修改其中的值)
      全局环境中不能调用局部变量 也不能修改

      函数
      global()
      (在函数内部使用,可以对全局变量进行操作)

      • 1、可以在局部环境中定义全局变量

      • 2、可以在局部环境中修改全局变量

      nonlocal()
      (在内函数中使用,可以在内函数中修改外函数中的局部变量)

      关键字:

      locals
      1、locals获取当前作用域当中所有的变量
      如果在全局调用locals之后,获取的是打印之前的所有变量,返回字典,全局作用域
      如果在局部调用loclas之后,获取的是调用之前的所有变量,返回字典,局部作用域

      globals
      2、globals只获取全局空间中的所有变量
      如果在全局调用globals之后,获取的是打印之前的所用变量,返回字典,全局作用域
      如果在局部调用globals之后,获取的是调用之前的所用变量,返回字典,全局作用域

      本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
      作者最新文章
      编程开发 Python
      相关文章 更多
      python删除一个列表里的重复元素的方法与代码示例
      python删除一个列表里的重复元素的方法与代码示例

      学习如何使用Python高效删除列表中的重复元素。本文提供5种常见方法的代码示例,涵盖保持顺序与不保持顺序的场景,适合初学者和进阶开发者参考。

      Python写接口的步骤及完整代码示例
      Python写接口的步骤及完整代码示例

      详细讲解使用Python编写Web接口的核心步骤与完整代码示例,涵盖环境准备、路由定义、数据校验、服务启动及调试测试方法。

      codex怎么读取word文档及docx文件操作教程
      codex怎么读取word文档及docx文件操作教程

      介绍如何利用编程工具读取和解析Word文档(docx格式),涵盖基础文本提取代码示例、结构化数据处理逻辑,以及处理复杂排版时的技术局限与替代方案。

      怎么在Python中调用C语言代码提升性能
      怎么在Python中调用C语言代码提升性能

      详细讲解在Python中调用C语言代码提升性能的完整实践指南,包含原理分析、编译步骤、ctypes与CFFI具体实现、性能对比及常见陷阱。

      Python与C语言的性能差异及底层原理
      Python与C语言的性能差异及底层原理

      深入解析Python与C语言在执行效率上的数量级差异,从编译机制、变量内存布局、动态类型推断到GIL锁,系统阐明底层核心原理。

      Python和C语言哪个更适合编程入门
      Python和C语言哪个更适合编程入门

      客观对比Python与C语言在心智负担、底层机制与学习反馈上的核心差异,提供清晰有据的选择标准与切实的入门学习路径。

      selenium上传文件教程本地文件路径设置方法
      selenium上传文件教程本地文件路径设置方法

      深入解析Selenium处理文件上传的技术细节,涵盖标准HTML控件的路径直接注入法与非标准控件的系统级模拟方案,提供Windows与Linux环境下的路径设置最佳实践及常见异常排查。

      大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景
      大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景

      针对大数据工程场景,系统对比Java、Scala与Python在执行性能、生态结合、开发效率和维护成本上的核心差异,给出清晰的架构选型依据与落地方案。

      langgraph python guide中文入门教程详解
      langgraph python guide中文入门教程详解

      本篇LangGraph Python中文入门教程详解,系统梳理StateGraph状态机定义、节点编写、边与条件路由、检查点持久化(MemorySaver)等核心机制,提供从环境安装到完整循环智能体构建的代码示例与实操指导。

      Windows 安装 Python:从官方入口到虚拟环境的可复现实践
      Windows 安装 Python:从官方入口到虚拟环境的可复现实践

      面向后端开发者,基于 Python 官方文档说明如何在 Windows 上安装 Python、创建 venv 虚拟环境及使用 pip 管理依赖。包含可复制命令、验证方法及工具选择边界,避免常见配置误区。

      查看更多
      精品专题 更多
      装机必备
      装机必备

      正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

      Windows
      Windows

      正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

      PDF教程
      PDF教程

      正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

      Mac软件 更多
      讯飞智作 网页版
      讯飞智作 网页版
      Windows/ macOS/ Linux

      讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

      火山引擎 网页版
      火山引擎 网页版
      Windows/ macOS/ Linux

      火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

      Aperty macOS版
      Aperty macOS版
      macOS

      Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

      WINDOWS 更多
      讯飞智作 网页版
      讯飞智作 网页版
      Windows/ macOS/ Linux

      讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

      火山引擎 网页版
      火山引擎 网页版
      Windows/ macOS/ Linux

      火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

      PixTV 网页版
      PixTV 网页版
      Windows

      PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。