day 15 名称空间和作用域

1 名称空间

1.1 名称空间的定义和划分

​ 名称空间即存放名字与对象映射/绑定关系的地方。对于x=3，Python会申请内存空间存放对象 3，然后将名字x与3的绑定关系存放于名称空间中，del x表示清除该绑定关系。

​ 名称空间 namespacs：存放名字的地方，是对栈区的划分有了名称空间之后，就可以在栈区中存放相同的名字，详细的，名称空间分为三种

1.1 内置名称空间

伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些内置的名字，比如内建函数名

存放的名字：存放的 python 解释器内置的名字

\>>> print

<built-in function print>
-------------------------------------
\>>> input

<built-in function input>

存活周期：python 解释器启动则产生，python 解释器关闭则销毁

1.2 全局名称空间

​ 伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中，如下名字

存放的名字：只要不是函数内定义 也不是内置的，剩下的都是全局名称空间的名字

存活周期：python 文件执行则产生，python 文件运行完毕后销毁

import sys #模块名sys

x=1 #变量名x

if x == 1:
    y=2 #变量名y

def foo(x): #函数名foo
    y=1
    def bar():
        pass

Class Bar: #类名Bar
    pass

1.3 局部名称空间

​ 存放的名字：在调用函数时，运行函数体代码过程中产生的函数内的名字# 存活周期：在调用函数时存活，函数调用完毕后则销毁

​ 伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中

def foo(x):
    y=3 #调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部名称空间中

1.2 名称空间的加载顺序

​ 名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，

​ 查找顺序为：局部名称空间->全局名称空间->内置名称空间。

1.3 销毁顺序

局部名称空间>全局名空间>内置名称空间

1.4 名字的查找优先级

• 规律：当前所在的位置向上一层一层查找

内置名称空间

全局名称空间

局部名称空间

• 如果当前在局部名称空间：

在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

x=100          #全局作用域的名字x

def foo():
    x=300        #局部作用域的名字x
    print(x)      #在局部找x
    
foo()               #结果为300

• 如果当前在全局名称空间

全局名称空间->内置名称空间

x=100

def foo():
    x=300       #在函数调用时产生局部作用域的名字x
    
foo()
print(x)          #在全局找x,结果为100

​ Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域

示范 1:

x=1

def outer():
        x=2
        def inner(): # 函数名inner属于outer这一层作用域的名字
                x=3
                print('inner x:%s' %x)
        inner()
        print('outer x:%s' %x)

outer() 
----------------------------------------
#结果为
inner x:3
outer x:2

示范 2：名称空间的"嵌套"关系是以函数定义阶段为准，与调用位置无关

x=1

def func():
	 print(x)

 def foo():
	 x=222
	 func()

 foo()
 ----------------------
 结果为：1

示范 3：函数嵌套定义

input=111

def f1():
	 def f2():
			 input=333
			 print(input)
	 input=222
	f2()
	
 f1()

示范 4：

x=111

def func():
	 print(x) 

 x=222

 func()    

2 作用域

按照名字作用范围的不同可以将三个名称空间划分为两个区域：

全局作用域：位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）；

局部作用域：位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）。

• 全局作用域：内置名称空间 、全局名称空间

1 全局存活

2 全局有效: 被所有函数共享

x=111

def foo():
	print(x,id(x))

 def bar():
	 print(x,id(x))

 foo()
 bar()
 print(x,id(x))

• 局部作用域: 局部名称空间的名字

1 临时存活

2 局部有效:函数内有效

def foo(x):
	 def f1():
		 def f2():
			 x = 1
			 print(x)

3 global与nonlocal

​ 在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字

​ 调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals()

• 示范 1：如果在局部想要修改全局的名字对应的值（不可变类型），需要用 global

x=111

def func():
	global x           # 声明 x 这个名字是全局的名字，不要再造新的名字了
	x=222

func()

print(x)  # 222

• 示范 2：当实参的值为可变类型时，函数体内对该值的修改将直接反应到原值，

num_list=[1,2,3]

def foo(nums):
    nums.append(5)

foo(num_list)
print(num_list)
------------------------------
#结果为
[1, 2, 3, 5]

• nonlocal(了解): 修改函数外层函数包含的名字对应的值（不可变类型）。对于嵌套多层的函数，使用nonlocal关键字可以将名字声明为来自外部嵌套函数定义的作用域（非全局）

def  f1():
        x=2
        def f2():
                nonlocal x
                x=3
        f2()             #调用f2(),修改f1作用域中名字x的值
        print(x)       #在f1作用域查看x

f1()
-----------------------------------
#结果
3