引入例子拆解


源码

1. class A:
   
2.     def __init__(self):
   
3.         self.test = 0
   
4. 
   
5. def add(c, k):
   
6.     c.test = c.test + 1
   
7.     k = k + 1
   
8. 
   
9. def main():
   
10.     Count = A()
    
11.     k = 0
    
12.    
    
13.     for i in range(0, 25):
    
14.         add(Count, k)
    
15.    
    
16.     print("Count.test=", Count.test)
    
17.     print("k=", k)
    
18. 
    
19. main()

复制代码

运行结果如下图

代码解析

这段代码定义了一个类

1. A

复制代码

和一个函数

1. add

复制代码

，然后在

1. main

复制代码

函数中创建了类

1. A

复制代码

的一个实例，并使用了一个局部变量

1. k

复制代码

。
1.类定义：

1. class A:
   
2.     def __init__(self):
   
3.         self.test = 0

复制代码

这里定义了一个名为

1. A

复制代码

的类，它有一个特殊的方法

1. __init__

复制代码

，这是一个构造函数，当创建类

1. A

复制代码

的新实例时会被自动调用。在这个方法中，初始化实例变量

1. self.test

复制代码

并将其设置为0。
2.函数定义：

1. def add(c, k):
   
2.     c.test = c.test + 1
   
3.     k = k + 1

复制代码

这里定义了一个名为

1. add

复制代码

的函数，它接受两个参数

1. c

复制代码

和

1. k

复制代码

。函数内部，它将参数

1. c

复制代码

的

1. test

复制代码

属性增加1，并将参数

1. k

复制代码

的值增加1。
3.主函数：

1. def main():
   
2.     Count = A()
   
3.     k = 0
   
4.    
   
5.     for i in range(0, 25):
   
6.         add(Count, k)
   
7.    
   
8.     print("Count.test=", Count.test)
   
9.     print("k=", k)

复制代码

1. main

复制代码

函数是程序的入口点。首先，它创建了类

1. A

复制代码

的一个实例，并将其赋值给变量

1. Count

复制代码

。然后，它初始化一个局部变量

1. k

复制代码

并将其设置为0。
接下来，

1. main

复制代码

函数使用一个

1. for

复制代码

循环，循环25次，每次调用

1. add

复制代码

函数，并将

1. Count

复制代码

实例和

1. k

复制代码

变量作为参数传递。
在循环结束后，

1. main

复制代码

函数打印出

1. Count.test

复制代码

和

1. k

复制代码

的值。
4.调用主函数：

1. main()

复制代码

最后，调用

1. main

复制代码

函数来执行程序。
输出结果：

• 1. Count.test

  复制代码
  的值将会是25，因为在每次调用
  1. add

  复制代码
  函数时，
  1. Count

  复制代码
  实例的
  1. test

  复制代码
  属性都会增加1。
  
• 1. k

  复制代码
  的值将会是0，因为在
  1. add

  复制代码
  函数中对
  1. k

  复制代码
  的修改并不会影响
  1. main

  复制代码
  函数中的
  1. k

  复制代码
  变量。在
  1. add

  复制代码
  函数中，
  1. k

  复制代码
  被重新绑定为一个新的局部变量，它只是临时地覆盖了传入的
  1. k

  复制代码
  值，但这个修改只在
  1. add

  复制代码
  函数的局部作用域内有效。一旦
  1. add

  复制代码
  函数执行结束，这个局部变量
  1. k

  复制代码
  就会被销毁，而
  1. main

  复制代码
  函数中的
  1. k

  复制代码
  变量保持不变。
  

因此，最终的输出为：

1. Count.test= 25
   
2. k= 0

复制代码

Python3命名空间和作用域


命名空间

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。每个命名空间都有一个与之关联的作用域。
命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
如下一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
  
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。包含模块中的所有全局变量和函数。
  
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是），只在这个函数或类中有效。
  

命名空间查找顺序

假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间 -> 全局命名空间 -> 内置命名空间。
如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常:

1. NameError: name 'runoob' is not defined。

复制代码

命名空间的生命周期

命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。
因此，我们无法从外部命名空间访问内部命名空间的对象。

1. # var1 是全局名称
   
2. var1 = 3
   
3. def some_func():
   
4.   
   
5.     # var2 是局部名称
   
6.     var2 = 6
   
7.     def some_inner_func():
   
8.   
   
9.         # var3 是内嵌的局部名称
   
10.         var3 = 8

复制代码

相同的对象名称可以存在于多个命名空间中，如下图。

作用域

作用域就是一个 Python 程序可以直接访问命名空间的正文区域，即变量可以被访问的区域。
在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python 的作用域一共有4种，分别是：
有四种作用域：

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。这是最内层的作用域，通常指的是函数内部的作用域。在这个作用域内声明的变量，只能在该函数内部被访问和修改。
  
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。当函数定义在另一个函数内部时，内部函数可以访问外部函数的局部变量，即允许嵌套函数访问外层函数的局部变量。这里的外部函数的作用域就被称为封闭作用域。封闭作用域中的变量可以被内部函数访问，但内部函数不能直接修改外部函数的局部变量，除非使用
  1. nonlocal

  复制代码
  声明。
  
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。这是模块级别的命名空间，包含了模块中定义的所有全局变量和函数。全局变量可以在模块内的任何位置被访问和修改，除非它们被局部作用域中的同名变量遮蔽。
  
• B（Built-in）： 包含了内建的变量/关键字等，最后被搜索。这是最外层的作用域，包含了Python解释器提供的内置函数和变量，如
  1. len()

  复制代码
  ,
  1. print()

  复制代码
  ,
  1. True

  复制代码
  ,
  1. False

  复制代码
  等，可以被任何模块访问。
  

规则顺序： L –> E –> G –> B。
在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

如果在查找过程中找到了变量，就不会再继续向上查找。如果在当前作用域中找到了同名的变量，那么这个变量会遮蔽外层作用域中的同名变量。例如，如果在局部作用域中声明了一个变量，那么它就会遮蔽全局作用域中的同名变量。

1. g_count = 3  # 全局作用域
   
2. def outer():
   
3.     o_count = 4  # 闭包函数外的函数中
   
4.     def inner():
   
5.         i_count = 5  # 局部作用域

复制代码

内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:

1. import builtins
   
2. dir(builtins)

复制代码

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

实例中name变量定义在if语句块中，但外部还是可以访问的。
如果将name定义在函数中，则它就是局部变量，外部无法访问：

从报错的信息上看，说明了 name_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。

1. 在 Python 中，return 语句用于从函数中返回一个值。当函数调用一个 return 语句时，函数的执行将停止，并将一个值返回给函数调用者。在函数中使用 return 语句可以返回任何类型的数据，包括数字，字符串，列表，元组和字典等。
   
2. 使用 return 语句时，我们可以选择是否返回值。如果函数没有 return 语句，函数将返回 None 值。None 表示空值，意味着它没有值，与 0，'' 或空列表不同。

复制代码

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

1. 让我们通过几个关键点来清晰明了地理解<strong>局部变量和全局变量的区别</strong>：
   
2. <strong>定义位置</strong>
   
3. <ul><li><strong>局部变量</strong>：在函数内部定义的变量。</li><li><strong>全局变量</strong>：在所有函数外部定义的变量，通常是在模块级别。</li></ul>
   
4. <strong>作用域</strong>
   
5. <ul><li><strong>局部变量</strong>：仅在定义它们的函数内部可见。</li><li><strong>全局变量</strong>：在整个程序中可见，包括所有函数内部。</li></ul>
   
6. <strong>生命周期</strong>
   
7. <ul><li><strong>局部变量</strong>：当函数被调用时创建，当函数执行结束时销毁。</li><li><strong>全局变量</strong>：程序运行期间一直存在，直到程序结束。</li></ul>
   
8. <strong>修改规则</strong>
   
9. <ul><li><strong>局部变量</strong>：在函数内部对局部变量的修改只影响该函数内部的变量。</li><li><strong>全局变量</strong>：在函数内部对全局变量的修改会影响全局变量的值，但需要使用[code]global

复制代码

关键字来声明。
[/code] 如下实例：

1. x = 10  # 全局变量
   
2. 
   
3. def my_function():
   
4.     print("Inside function, x =", x)  # 访问全局变量x
   
5.     y = 20  # 局部变量
   
6.     print("Inside function, y =", y)
   
7. 
   
8. my_function()
   
9. print("Outside function, x =", x)  # 访问全局变量x
   
10. # print("Outside function, y =", y)  # 这将引发错误，因为y是局部变量

复制代码

在这个例子中，x是全局变量，可以在函数内部和外部访问。而y是局部变量，只能在my_function函数内部访问。
如果我们尝试在函数外部访问y，将会引发一个NameError，因为y的作用域仅限于my_function函数内部。

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键词了。
例：

修改全局变量

如果想在函数内部修改全局变量，需要使用global关键字：

1. x = 10  # 全局变量
   
2. 
   
3. def my_function():
   
4.     global x  # 声明x是全局变量
   
5.     print("Inside function, x =", x)
   
6.     x = 20  # 修改全局变量x
   
7.     print("Inside function, x =", x)
   
8. 
   
9. my_function()
   
10. print("Outside function, x =", x)  # x的值也被修改了

复制代码

在这个例子中，通过使用global关键字，my_function函数内部的修改影响了全局变量

1. x

复制代码

的值。


最佳实践

• 使用局部变量：尽量使用局部变量，因为它们的作用域有限，有助于避免命名冲突和意外的修改。
  
• 谨慎使用全局变量：全局变量可能会导致代码难以理解和维护，因为它们可以在程序的任何地方被修改。如果确实需要使用全局变量，确保它们的使用是必要的，并且明确地使用
  1. global

  复制代码
  关键字声明。
  

修改封闭作用域中的变量

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要nonlocal关键字了。nonlocal关键字在Python中用于在嵌套的函数作用域中修改变量。当你有一个嵌套函数，并且想要在内部函数中修改外部函数的变量时，可以使用nonlocal关键字。这与global关键字的作用类似，但nonlocal用于封闭作用域中的变量，而不是全局作用域。
nonlocal关键字通常用在闭包（closure）中，即一个函数内定义了另一个函数，内部函数可以访问外部函数的变量。

1. def outer():
   
2.     x = 10  # 外部函数的局部变量
   
3. 
   
4.     def inner():
   
5.         nonlocal x  # 声明x是封闭作用域中的变量
   
6.         print("Inside inner, x =", x)
   
7.         x = 20  # 修改外部函数的局部变量x
   
8.         print("Inside inner, x =", x)
   
9. 
   
10.     inner()
    
11.     print("Outside inner, x =", x)
    
12. 
    
13. outer()

复制代码

在这个例子中：

• outer函数定义了一个局部变量
  1. x

  复制代码
  。
  
• innner函数是嵌套在outer函数内部的。
  
• 在inner函数中，使用nonlocal x声明x是封闭作用域中的变量，即outer函数的局部变量。
  
• 在inner函数中修改x的值，这个修改会影响到outer函数中的x。
  

与global的区别

• global：用于修改全局作用域中的变量。
  
• nonlocal：用于修改封闭作用域中的变量，通常是嵌套函数中的外部函数的局部变量。
  

注意事项

• 使用nonlocal时，变量必须在封闭作用域中定义，否则会引发UnboundLocalError。
  
• nonlocal关键字不能用于类定义中。
  

最佳实践

• 在使用嵌套函数时，如果需要在内部函数中修改外部函数的变量，使用nonlocal关键字。
  
• 避免过度使用nonlocal，因为它可能会使代码的可读性和可维护性降低。尽量通过参数传递和返回值来实现函数之间的数据交换。
  

特殊情况

另外有一种特殊情况，假设下面这段代码被运行：

1. a = 10
   
2. def test():
   
3.     a = a + 1
   
4.     print(a)
   
5. test()

复制代码

错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。
修改 a 为全局变量：

1. a = 10
   
2. def test():
   
3.     global a
   
4.     a = a + 1
   
5.     print(a)
   
6. test()

复制代码

也可以通过函数参数传递：

1. a = 10
   
2. def test(a):
   
3.     a = a + 1
   
4.     print(a)
   
5. test(a)

复制代码

输出结果均为：11。如下图：

内置函数：locals和globals

这两个函数主要提供，基于字典的访问局部和全局变量的方式。locals()和globals()是两个内置函数，分别用于访问当前局部和全局符号表。这些符号表实际上是字典，其中包含了当前作用域中的变量名和它们的值。
在理解这两个函数时，首先来理解一下 Python 中的名字空间概念。Python 使用叫做名字空间的东西来记录变量的轨迹。名字空间只是一个字典，它的键字就是变量名，字典的值就是那些变量的值。
实际上，名字空间可以像 Python 的字典一样进行访问。
每个函数都有着自已的名字空间，叫做局部名字空间，它记录了函数的变量，包括函数的参数和局部定义的变量。每个模块拥有它自已的名字空间，叫做全局名字空间，它记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。还有就是内置名字空间，任何模块均可访问它，它存放着内置的函数和异常。
当一行代码要使用变量 x 的值时，Python 会到所有可用的名字空间去查找变量，按照如下顺序：

• 1、局部名字空间 - 特指当前函数或类的方法。如果函数定义了一个局部变量 x，Python将使用这个变量，然后停止搜索。
  
• 2、全局名字空间 - 特指当前的模块。如果模块定义了一个名为 x 的变量，函数或类，Python将使用这个变量然后停止搜索。
  
• 3、内置名字空间 - 对每个模块都是全局的。作为最后的尝试，Python 将假设 x 是内置函数或变量。
  

如果 Python 在这些名字空间找不到 x，它将放弃查找并引发一个 NameError 的异常，同时传递 There is no variable named 'x' 这样一条信息。
局部变量函数 locals 例子（locals 返回一个名字/值对的字典）：

lobals()

• locals()函数返回一个代表当前局部符号表的字典。
  
• 这个字典包含了当前作用域中定义的所有变量，包括函数参数和局部变量。
  

1. def my_function():
   
2.     local_var = 20
   
3.     print(locals())
   
4. 
   
5. my_function()

复制代码

输出将类似于：

1. {
   
2.     'local_var': 20,
   
3.     '__module__': '__main__',
   
4.     '__annotations__': {},
   
5.     '__doc__': None,
   
6.     ...
   
7. }

复制代码

locals()返回的字典包含了在函数my_function中定义的所有局部变量。

1. def foo(arg, a):
   
2.     x = 1
   
3.     y = 'xxxxxx'
   
4.     for i in range(10):
   
5.         j = 1
   
6.         k = i
   
7.     print(locals())
   
8. #调用函数的打印结果   
   
9. foo(1,2)

复制代码

1. 这段代码定义了一个名为 foo的函数，它接受两个参数 arg和 a。在函数内部，定义了两个局部变量 x和 y，并初始化了它们的值。然后，函数进入一个 for 循环，循环10次，每次循环中定义了两个变量 j 和 k，并分别将 j 初始化为1，将 k 设置为当前循环的索引 i。
   
2. 在循环结束后，函数打印出当前的局部变量字典 locals()。这个字典包含了函数内所有局部变量的名称和值。
   
3. 为什么结果是 `{'arg': 1, 'a': 2, 'x': 1, 'y': 'xxxxxx', 'i': 9, 'j': 1, 'k': 9}` 呢？让我们逐步分析：
   
4.  arg 和 a 是函数的参数，分别被赋值为1和2。
   
5.  x 和 y 是在函数体中定义的局部变量，分别被赋值为1和字符串 'xxxxxx'。
   
6.  在 for 循环中，i 从0开始，每次循环递增1，直到9。在循环的最后一次，i 的值是9。
   
7. j 在每次循环的开始被重新赋值为1，因此不管循环多少次，j 的值总是1。
   
8. k 在每次循环中被赋值为当前的 i 值，因此在最后一次循环中，k 的值也是9。
   
9. 由于 locals() 返回的是函数执行到当前点的所有局部变量的快照，所以在 for 循环结束后，locals() 包含了所有这些变量及其最终的值。这就是为什么看到的结果是包含所有这些变量及其值的字典。

复制代码

1. <strong>from module import</strong> 和 <strong>import module</strong> 之间的不同。使用 import module，模块自身被导入，但是它保持着自己的名字空间，这就是为什么需要使用模块名来访问它的函数或属性（module.function）的原因。但是使用 from module import，实际上是从另一个模块中将指定的函数和属性导入到你自己的名字空间，这就是为什么你可以直接访问它们却不需要引用它们所来源的模块的原因。

复制代码

globals()

• globals()函数返回一个代表当前全局符号表的字典。
  
• 这个字典包含了在模块顶级作用域中定义的所有变量，包括函数、类、导入的模块和变量等。
  

1. # 定义一些全局变量
   
2. global_var1 = 10
   
3. global_var2 = "Hello"
   
4. 
   
5. # 打印全局变量字典
   
6. print(globals())

复制代码

输出将类似于：

1. {
   
2.     '__name__': '__main__',
   
3.     'global_var1': 10,
   
4.     'global_var2': 'Hello',
   
5.     ...
   
6. }

复制代码

globals()返回的字典包含了当前模块的所有全局变量。注意，输出的具体内容可能会根据你定义的其他全局变量而有所不同。

与globals()的区别

locals 是只读的，globals 不是。
locals 不可修改，globals 可以修改，原因是：

• locals() 实际上没有返回局部名字空间，它返回的是一个拷贝。所以对它进行修改，修改的是拷贝，而对实际的局部名字空间中的变量值并无影响。
  
• globals() 返回的是实际的全局名字空间，而不是一个拷贝与 locals 的行为完全相反。
  

所以对 globals 所返回的 dictionary 的任何的改动都会直接影响到全局变量的取值。

1. z = 6 #定义全局变量  
   
2. def foo(arg):  
   
3.     x = 1  
   
4.     print( locals() )  
   
5.     print('x=',x)
   
6.     locals()['x'] = 2 #修改的是局部名字空间的拷贝，而实际的局部名字空间中的变量值并无影响。  
   
7.     print( locals() )
   
8.     print( "x=",x )
   
9. 
   
10. foo(3)  
    
11. print( globals() )
    
12. print( 'z=',z )
    
13. globals()["z"] = 8 #globals（）返回的是实际的全局名字空间，修改变量z的值  
    
14. print( globals() )
    
15. print( "z=",z )

复制代码

输出将类似于：

1. {'arg': 3, 'x': 1}
   
2. x= 1
   
3. {'arg': 3, 'x': 1}
   
4. x= 1
   
5. {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 6, 'foo': <function foo at 0x10ae48e18>}
   
6. z= 6
   
7. {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 8, 'foo': <function foo at 0x10ae48e18>}
   
8. z= 8

复制代码

注意事项

• 使用locals()和globals()时要小心，因为不当使用可能会导致代码难以理解和维护。
  
• 在嵌套函数中使用locals()时，它返回的是当前函数的局部变量，而不是外部函数的局部变量。
  
• 修改locals()或globals()字典中的值会直接影响作用域中的变量，但通常不推荐这样做，因为它可能会导致代码难以追踪和理解。
  

总结

到此这篇关于Python中局部变量和全局变量的文章就介绍到这了,更多相关Python局部变量和全局变量内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/python/339639jkw.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！