25. Python的命名空间（NameSpace）和变量作用域

《Python编程的术与道：Python语言入门》视频课程
《Python编程的术与道：Python语言入门》视频课程链接：https://edu.csdn.net/course/detail/27845

命名空间（名称空间,NameSpace）

Python中的名称是什么？

名称(Name)又称为标识符(identifier)，是给对象的一个名字。Python中一切皆对象 (Everything in Python is an object)。 Name is a way to access the underlying object.

a = 2

print(type(2))
print('id(2) =', id(2))
print('id(a) =', id(a))

<class 'int'>
id(2) = 140716488237488
id(a) = 140716488237488

例如，当执行赋值a = 2时，这里2是存储在内存中的一个对象，而a是与之关联的名称。 我们可以通过内置函数id()获得某个对象的地址（在RAM中）。

a = 2
print('id(a) =', id(a))

id(a) = 140716488237488

a = a+1
print('id(a) =', id(a))

id(a) = 140716488237520

print('id(3) =', id(3))

id(3) = 140716488237520

b = 2
print('id(2) =', id(2))

id(2) = 140716488237488

最初，创建一个对象2并将名称a与之关联，当们执行a = a + 1时，将创建一个新的对象3，现在a将其与该对象关联。

请注意，执行 a = a + 1后， id(a)和id(3)具有相同的值。

此外，当执行b = 2时，新名称b与先前的对象2相关联。

这样效率比较高，因为Python不必创建新的重复对象。 名称绑定的这种动态特性使Python变得功能强大。

名称可以引用任何类型的对象。

a = 5
a = 'Hello World!'
a = [1,2,3]

所有这些都是有效的，并且a将在不同例子中代表三种不同类型的对象。 函数也是对象，因此名称也可以引用它们。

def printHello():
    print("Hello")     
a = printHello()

Hello

什么是Python中的命名空间？

简而言之，名称空间是名称的集合。

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

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

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

这就是为什么内置的函数（例如id()，print()等）始终可以从程序的任何部分使用的原因。

每个模块创建自己的全局名称空间 (Global Namespace)。这些不同的名称空间是隔离的。因此，不同模块中可能存在的相同名称而不会冲突。

模块可以具有各种函数和类。调用函数时会创建一个局部名称空间(Local Namespace)，其中定义了模块内的所有名称。

变量作用域 (Scope)

尽管定义了各种特别的名称空间，但我们可能无法从程序的每个部分访问它们。 作用域(Scope)的概念开始起作用。

作用域是程序的一部分，从那里可以直接访问名称空间而无需任何前缀。

并非程序的所有部分都可以访问所有变量。

程序中可访问变量的部分称为其“作用域”(Scope)，并由声明变量的位置确定。

Python具有三个不同的变量作用域：

• 局部作用域 (Local scope)
• 全局作用域 (Global scope)
• 包含作用域 (Enclosing scope)

局部作用域

在函数内声明的变量具有局部作用域。

从声明它的位置到函数结束都可以访问它，并且在函数执行期间一直存在。

示例：获取局部变量x的值

def myfunc():
    x = 42      # local scope x
    print(x)

myfunc()       

42

函数调用退出时，将从内存中删除局部变量。

示例：尝试获取def之外的局部变量x的值

def myfunc():
    x = 42      # local scope x
    print(x)
myfunc()
print(x)       

42



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-9-0dc7b6d1696d> in <module>
      3     print(x)
      4 myfunc()
----> 5 print(x)


NameError: name 'x' is not defined

全局作用域

在所有函数外部声明的变量具有全局作用域。

在整个文件中以及在导入该文件的任何文件中都可以访问它。

示例：获取全局变量x的值

x = 42          # global scope x

def myfunc():
    print(x)    # x is 42 inside def

myfunc()
print(x)        # x is 42 outside def

42
42

全局变量通常用于标志（flags), 如指示条件是否为真的布尔变量。

例如，某些程序使用名为verbose的flag来报告有关操作的更多信息。

verbose = True
def op1():
    if verbose:
        print('Running operation 1')     
op1()

Running operation 1

在函数内部修改全局变量

尽管可以在函数内部或外部访问全局变量，但不能在函数内部对其进行修改。

下面是一个尝试在函数内重新赋值全局变量的示例。

x = 42          # global scope x
def myfunc():
    x = 0
    print(x)    # x is 0

myfunc()
print(x)        # x is still 42

0
42

在这里，全局变量x的值没有改变。 因为Python创建了一个名为x的新局部变量； 函数结束时消失，对全局变量没有影响。

如果在函数内部和外部使用相同的变量名进行操作，Python会将它们视为两个单独的变量，一个在全局作用域内可用（在函数外部），而一个在局部作用域内可用（在函数内部）

要访问全局变量而不是局部变量，需要使用global关键字显式声明x为global。

示例：在函数内重新赋值全局变量

x = 42          # global scope x
def myfunc():
    global x
    x = 0
    print(x)    # global x is now 0

myfunc()
print(x)        # x is 0

0
0

现在，函数内部的x指向函数外部的x，因此更改函数内部的x会更改函数外部的x。

下面是另一个在函数内部尝试更新一个全局变量的示例。

x = 42          # global scope x

def myfunc():
    x = x + 1   # raises UnboundLocalError
    print(x)

myfunc()
print(x)

---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

<ipython-input-14-42abcaf5c146> in <module>
      5     print(x)
      6 
----> 7 myfunc()
      8 print(x)


<ipython-input-14-42abcaf5c146> in myfunc()
      2 
      3 def myfunc():
----> 4     x = x + 1   # raises UnboundLocalError
      5     print(x)
      6 


UnboundLocalError: local variable 'x' referenced before assignment

在这里，Python假定x是一个局部变量，这意味着在定义它之前先读取了它。

同样，解决方案是将x声明为global。

示例：在函数内部修改全局变量

x = 42          # global scope x

def myfunc():
    global x
    x = x + 1   # global x is now 43
    print(x)

myfunc()
print(x)        # x is 43

43
43

还有一种从非全局作用域更新全局变量的方法–使用globals()函数。

包含作用域 （Enclosing Scope）

如果在包含函数（enclosing function)中声明了变量，则它对于包含函数而言是非局部的。

它允许在外部但非全局作用域内赋值变量。

下面是一个示例，试图在包含函数（内部）中重新赋值包含函数（外部）的局部变量。

# enclosing function
def f1():
    x = 42
    
    # nested function
    def f2():
        x = 0
        print(x)    # x is 0
    f2()
    print(x)        # x is still 42
    
f1()

0
42

在这里，现有变量x的值没有变化。 因为Python创建了一个名为x的新局部变量，该局部变量在外部作用域中隐藏了该变量。

防止这种行为是使用nonlocal关键字。

# enclosing function
def f1():
    x = 42
    
    # nested function
    def f2():
        nonlocal x
        x = 0
        print(x)    # x is now 0
    f2()
    print(x)        # x remains 0
    
f1()

0
0

现在，包含函数内部的x引用函数外部的x，因此更改函数内部的x会更改函数外部的x。

nonlocal的用法与global的用法非常相似，不同之处在于前者主要用于包含方法。

作用域规则 – LEGB Rule

引用变量时，Python遵循LEGB规则并按此顺序搜索四个作用域：

首先在局部（L）作用域内，

然后在任何包含的（E）函数和lambda的局部作用域内，

然后在全局（G）作用域内，

最后是内置（B）作用域

并在第一次出现时停止。 如果找不到匹配项，Python会引发NameError异常。