Python命名空间（Namespaces）和作用域（Scopes）讲座

谁践踏了优雅 2022-12-04 07:35 131阅读 0赞

### Python命名空间（Namespaces）和作用域（Scopes）讲座 ###

命名空间(名称空间Namespace)，是名称到对象的映射。它表示着一个标识符（identifier）的可见范围。在编程语言中，名字空间是对作用域的一种特殊的抽象，在一些编程语言（例如C++和Python）中，名字空间本身的标识符也属于一个外层的名字空间，也即名字空间可以嵌套。

命名空间提供了在项目中避免名字冲突的一种方法。命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响—— 不同命名空间中的名称之间绝对没有关系，请牢记这一点。

多个名称（在多个作用域内）可以绑定到同一个对象。这在其他语言中称为别名。在处理不可变的基本类型（数字，字符串，元组）时可以安全地忽略它。但是，对于可变对象，如列表，字典和大多数其他类型在某些方面表现得像指针，如果函数修改了作为参数传递的对象，调用者将看到更改。

在python中，任何事物都是一个对象，用名称(Name)标识。名字是访问底层对象的途径（way）。

几个命名空间的例子：存放内置函数的集合（包含 abs() 这样的函数名，和内置的异常名称 BaseException、Exception 等等）；模块中的全局名称；函数中的局部名称，包括函数的参数和函数中的变量。 从某种意义上说，对象的属性集合也是一种命名空间的形式。

在不同时刻创建的命名空间拥有不同的生存期。包含内置名称的命名空间是在 Python 解释器启动时创建的，永远不会被删除。模块的全局命名空间在模块定义被读入时创建；通常，模块命名空间也会持续到解释器退出。被解释器的顶层调用执行的语句，从一个脚本文件读取或交互式地读取，被认为是 \_\_main\_\_ 模块调用的一部分，因此它们拥有自己的全局命名空间。（内置名称实际上也存在于一个模块中；这个模块称作 builtins 。）一个函数的局部命名空间在这个函数被调用时创建，并在函数返回或抛出一个不在函数内部处理的错误时被删除。当然，每次递归调用都会有它自己的局部命名空间。

变量的作用域（Scopes）决定了在哪一部分程序可以访问哪个特定的变量名称。

程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

前面算是概论，下面进行解释。

**名称 (名字Name)**

前面提到，在python中，任何事物都是一个对象，用名称 (Name)标识。名称是访问底层对象的途径（way）。

例如：当我们做赋值a = 2，这里的2是一个存储对象在内存，a是一个名称，我们可以联系到它。我们可以通过内置函数id()获取到某些对象的地址（在内存），参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

在这里，两者（2和a）都指向同一个对象。

下面这段代码

x = 2  \#  x对象被创建，指向对象2

x = x + 1  \# 一个新的x对象(不同于前一行的x对象)被创建，指向对象3

y = 2  \# 指向对象2

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1][]

解释，参见下图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2][]

python不能创建新的重复对象，名称（名字）是动态绑定的，这个特征使python很强大。下图展示a引用三种不同类型的对象实例

![20200908164335225.png][]

所有这些都是有效的。

函数也是对象，因此名称也可以引用它。

def printHello():

print("hello")

a = printHello()

**命名空间（名称空间Namespace）**

命名空间是一个名字的集合。

在Python中，可以将名称空间想象为已定义的每个名称到相应对象的映射。

不同的名称空间可以在给定的时间共存，但它们是完全隔离的。

当我们启动Python解释器时，会创建一个包含所有内置名称的名称空间，只要不退出就存在。

这就是为什么我们可以从程序的任何部分使用诸如id（）、print（）等内置函数。每个模块都创建自己的全局命名空间。

这些不同的名称空间是孤立的。因此，不同模块中可能存在的相同名称不会发生冲突。

模块可以有各种函数和类。调用函数时会创建一个局部命名空间，该函数中定义了所有名称。类似的，类也是如此。下图可能有助于澄清这一概念：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3][]

命名空间的生命周期

不同的命名空间在不同的时刻创建，有不同的生存期。

1、内置命名空间在 Python 解释器启动时创建，会一直保留，不被删除。

2、模块的全局命名空间在模块定义被读入时创建，通常模块命名空间也会一直保存到解释器退出。

3、当函数被调用时创建一个局部命名空间，当函数返回结果 或 抛出异常时，被删除。每一个递归调用的函数都拥有自己的命名空间。

**变量作用域（变量作用范围 Variable Scope）**

虽然定义了不同的惟一名称空间，但我们可能无法从程序的每个部分访问所有这些名称空间。范围的概念开始发挥作用。

Scope是程序的一部分，在这里可以不使用任何前缀直接访问命名空间。

在任何给定时刻，至少有三个嵌套作用域。

具有局部（local）名称的当前函数的作用域

具有全局（global）名称的模块的作用域

具有内置（built-in）名称的最外层作用域

如果在另一个函数中有一个函数，则有一个新的作用域——嵌套函数的外层函数的作用域——Enclosing（封闭）作用域。

例如：

g\_count = 0  \# 全局（global）作用域

def outer():

o\_count = 1  \# Enclosing作用域

def inner():

i\_count = 2  \# 局部（local）作用域

搜索使用顺序： L –> E –> G –> B。

在局部找不到，便会去局部外的局部找（即嵌套函数的外层函数找），再找不到就会去全局找，再者去内置中找。如何理解？见下面具体的例子：

先给出第一段测试代码

int = 0  
def fun1():  
    int = 1

def fun2():  
        int =2  
        print(int)

fun2()

fun1()

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4][]

函数 fun1() 的作用就是调用函数 fun2() 来打印 int 的值，因为 local 中的 int = 2，输出2

将上述代码函数 fun2() 中的 int = 2 删除或用\#注释掉，运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5][]

因为 local 找不到 int 的值，就去上一层 Enclosing中 寻找，发现 int = 1 输出1。

进一步删除函数 fun1() 中的 int = 1或用\#注释掉，运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6][]

因为 local 和Enclosing 都找不到 int 的值，便去 global 中寻找，发现 int = 0 输出0。

若再删除 int = 0或用\#注释掉，运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7][]

因为 local、Enclosing、global 中都没有 int 的值，便去 built-in 中寻找 int 的值，输出<class 'int'>。

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

if 2>1:  
    msg = "对啦"  
else:  
    msg = "错啦"

print(msg)

运行之，结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8][]

例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。

如果将 msg 定义在函数中，则它就是局部变量，外部不能访问。示例代码如下：

def test():  
    if 2>1:  
        msg = "对啦"  
    else:  
        msg = "错啦"

print(msg) \#此句将报错

运行之，结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9][]

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

关于命名空间和作用域的例子，又如：

def outer\_function():  
    b = 20

def inner\_func():  
        c = 30

a = 10

变量a是在全局命名空间里。变量b是在outer\_function()，c是内嵌到inner\_function()局部命名空间。

相对于inner\_function（），c是局部的，b是非局部的——嵌套函数的外层函数的变量，a是全局的。我们既可以读取也可以为c赋值，但只能从inner\_function（）读取b和a。

如果我们试图将值赋给b，那么在局部命名空间中会创建一个与非局部b不同的新变量b。当我们将值赋给a时，会发生同样的情况。

但是，如果我们声明a为全局的，那么所有的引用和赋值都指向全局a。同样，如果我们想重新绑定变量b，它必须声明为非局部的。下面的例子将进一步阐明这一点：

def outer\_function():  
    a = 20

def inner\_function():  
        a = 30  
        print('a =',a)

inner\_function()  
    print('a =',a)

a = 10  
outer\_function()  
print('a =',a)

运行之，输出结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10][]

在这个程序中，演示了三个不同的变量a在不同的名称空间中定义，并相应地进行访问。

下面程序使用了关键字global：

def outer\_function():  
    global a  
    a = 20

def inner\_function():  
        global a  
        a = 30  
        print('a =',a)

inner\_function()  
    print('a =',a)

a = 10  
outer\_function()  
print('a =',a)

运行之，输出结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11][]

在这里，由于使用了关键字global，所有引用和赋值都指向全局a。

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

关键字global再举例一例：修改全局变量 n，示例代码如下：

n = 1

def fun1():

global n  \# 需要使用 global 关键字声明

print(n)

n = 'abc'

print(n)

fun1()

print(n)

运行之，输出结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12][]

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了, 示例代码如下：

def outer():  
    m = 10

def inner():  
        nonlocal m   \# nonlocal关键字声明  
        m = 'abc'  
        print(m)

inner()

print(m)

outer()

运行之，输出结果参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13][]

参考：[https://www.programiz.com/python-programming/namespace][https_www.programiz.com_python-programming_namespace]

**补充：**

Python 作用域和命名空间

【**官方**：作用域和命名空间 [https://docs.python.org/zh-cn/3/tutorial/classes.html\#python-scopes-and-namespaces][https_docs.python.org_zh-cn_3_tutorial_classes.html_python-scopes-and-namespaces]

命名空间[https://docs.python.org/zh-cn/3/glossary.html\#term-namespace][https_docs.python.org_zh-cn_3_glossary.html_term-namespace]

嵌套作用域（nested scope）[https://docs.python.org/zh-cn/3/glossary.html\#term-nested-scope][https_docs.python.org_zh-cn_3_glossary.html_term-nested-scope] 】

作用域（ scope）是一个命名空间可直接访问的 Python 程序的文本区域。 这里的 “可直接访问” 意味着对名称的非限定引用会尝试在命名空间中查找名称。定义了一个代码块中名称的可见性。作用域是静态地确定的，但它们会被动态地使用。 在执行期间的任何时刻，会有 3 或 4 个命名空间可被直接访问的嵌套作用域：

最先搜索的最内部作用域包含局部名称；

从最近的封闭作用域开始搜索的任何封闭函数的作用域包含非局部名称，也包括非全局名称；

倒数第二个作用域包含当前模块的全局名称；

最外面的作用域（最后搜索）是包含内置名称的命名空间。

命名空间(Namespace)是从名称到对象的映射。命名空间是存放变量的场所。命名空间有局部、全局和内置的，还有对象中的嵌套命名空间（在方法之内）。命名空间通过防止命名冲突来支持模块化。

下面是几个命名空间的例子：存放内置函数的集合（包含 abs() 这样的函数，和内建的异常等）；模块中的全局名称；函数调用中的局部名称。

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

上面摘自官方文档，不太好理解，下面解析之。

一般有三种命名空间：

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

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14][]

命名空间查找顺序:

假设我们要使用变量，则 Python 的查找顺序为：**局部的命名空间去 -> 全局命名空间 -> 内置命名空间**。

这是由python解释器决定的。

作用域就是一个 Python 程序可以直接访问命名空间的正文区域。

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python 的作用域一共有4种，分别是：

有四种作用域：

*  **L（Local，局部）**：最内层，包含局部变量，比如一个函数/方法内部。
 *  **E（Enclosing，****封闭）**：包含了非局部(non-local)也非全局(non-global)的变量。比如嵌套函数之外层函数作用域l。
 *  **G（Global，全局）**：当前脚本的最外层，比如当前模块的全局变量。
 *  **B（Built-in，内建）**： 包含了内建的变量/关键字等，最后被搜索。

规则顺序： **L –> E –> G –gt; B**。

在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15][]

[https://fasionchan.com/python-source/virtual-machine/scope-namespace/][https_fasionchan.com_python-source_virtual-machine_scope-namespace]

[https://www.runoob.com/python3/python3-namespace-scope.html][https_www.runoob.com_python3_python3-namespace-scope.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221123/ffe746f156d84ee98428c34c1b31a75e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1]: /images/20221123/51b41c3d57cb45f9b7d9a55e105601e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2]: /images/20221123/633daa4f384747aa842071051f6ca81a.png
[20200908164335225.png]: /images/20221123/a072d4a41bf6413f9c9fce8e437c3812.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3]: /images/20221123/f68c8c3210fd47288ca311466a2bbd86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4]: /images/20221123/bd01b37d0259406ebc21156ae83d25e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5]: /images/20221123/d40a64bc20814aaa967df9c02e16dda4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6]: /images/20221123/6a3b74082e6142a29b6a36a2b08ff01f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7]: /images/20221123/bd8b7d83b43648d6958f4f756bbd9386.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8]: /images/20221123/613ea9c626ac4a4f9b1b84b19e9a0a8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 9]: /images/20221123/f290fb70795542c8bc6c3b992d49994c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 10]: /images/20221123/008a78b08e00488d93664bca3107d0c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 11]: /images/20221123/4c8be60fa58a4251bf793b8228734c3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 12]: /images/20221123/f43ea0e5a3da4e8389ed528dbf338d44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 13]: /images/20221123/6ea31ce4d694439db6cdc5a6ed32de60.png
[https_www.programiz.com_python-programming_namespace]: https://www.programiz.com/python-programming/namespace
[https_docs.python.org_zh-cn_3_tutorial_classes.html_python-scopes-and-namespaces]: https://docs.python.org/zh-cn/3/tutorial/classes.html#python-scopes-and-namespaces
[https_docs.python.org_zh-cn_3_glossary.html_term-namespace]: https://docs.python.org/zh-cn/3/glossary.html#term-namespace
[https_docs.python.org_zh-cn_3_glossary.html_term-nested-scope]: https://docs.python.org/zh-cn/3/glossary.html#term-nested-scope
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 14]: /images/20221123/44dfecc91af445778a847b04ee09eaa3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 15]: /images/20221123/db5492d4218f441a9cfb03f6680ef0e1.png
[https_fasionchan.com_python-source_virtual-machine_scope-namespace]: https://fasionchan.com/python-source/virtual-machine/scope-namespace/
[https_www.runoob.com_python3_python3-namespace-scope.html]: https://www.runoob.com/python3/python3-namespace-scope.html