python名称空间介绍

python名称空间介绍

名称空间

　　python 中名称空间分三种：
　　　　内置名称空间
　　　　全局名称空间
　　　　局部名称空间

　　　　内置名称空间：
　　　　　　原码里面的一些函数都是存在这个内存空间中，任何模块均可访问它，它存放着内置的函数和异常

　　　　全局名称空间：
　　　　　　当程序运行时，代码从上之下一次执行，他会将变量与值的关系存储在一个空间中，这个空间叫做全局名称空间（名称空间，命名空间）。
　　　　　　　　名称空间里面存的东西是，变量名与变量的内存地址的对应关系。
　　　　　　　　　　————（存的内容如:neame --> 13265654 一个对应关系）
　　　　　　　　当程序遇到函数时，他会将函数名存在内存中，函数体莫不关心。
　　　　　　　　　　————（也就是说全局名称空间，可以存变量名、变量值、函数名、但不存函数体）

　　　　局部名称空间：
　　　　　　函数外面是访问不到临时空间的内容的，随着函数的执行完毕，临时名称空间会释放掉,像这个临时开辟的空间叫局部名称空间（临时名称空间）。
　　　　　　当函数执行时，内存会临时开辟一个空间，存放函数体里面的代码（变量，代码等）

　　将命名空间分为两种作用域：
　　　　全局作用域和局部作用域

　　　　全局作用域包括：
　　　　　　内置名称空间。
　　　　　　全局名称空间。

　　　　局部作用域包括：
　　　　　　局部名称空间。

　　内存空间的加载顺序：
　　　　内置名称空间（列如打开PyCharm就会加载） ---> 全局名称空间(当程序开始执行时的时候加载) ---> 局部名称空间(当函数调用时开始加载)

　　函数的取值顺序：单向不可逆
　　　　局部名称空间(当函数调用时取值) -->全局名称空间(当程序执行时) -->内置名称空间
　　　　先从局部内存空间里取值，再次找全局名称空间里找，最后再找内置名称空间

　　　　注：取值顺序是单向不可逆的。（从小到大，不可逆的查找顺序）
　　　　函数中，取值顺序按局部，全局最后到内置，查找但只是引用，不能修改。

　　　　　　修改报错举例：
　　　　　　　　count = 0
　　　　　　　　def func1（）
　　　　　　　　count = count + 1
　　　　　　　　print（count）
　　　　　　　　func1（）
　　　　　　此例在函数引用count时更改了count会报错。局部引用没法修改全局和内置的变量值。

函数的嵌套：（记住两个关键点）
　　代码顺序执行，当见到函数名加括号，就是执行函数。
　　函数在没有执行完是不会执行下面的内容的。

　　注：
　　　　执行一个函数就会开辟一个临时空间进行存储，即每个函数都会单独开辟一个临时空间使用存放函数体内容。

　　　　举例：
　　　　　　# def func1():
　　　　　　# print(666)
　　　　　　#
　　　　　　# def func2():
　　　　　　# func1()
　　　　　　# print(333)
　　　　　　#
　　　　　　# def func3():
　　　　　　# func2()
　　　　　　# print(222)
　　　　　　# print(111)
　　　　　　# func3()
　　　　　　# print(555)

　　　　　　# def func1():
　　　　　　# name = 'susi'
　　　　　　# print(name)
　　　　　　# def func2():
　　　　　　# name1 = 'git'
　　　　　　# print(333)
　　　　　　# print(444)
　　　　　　# func2()
　　　　　　# func1()

取出名称空间内容方法：调用内置函数globals（）、locals（）

　　内置函数globals（） 全局名称空间内容，字典格式输出
　　　　反回一个字典，字典里面的内容是全局名称空间的内容
　　　　不论该函数在什么内存空间中，反回的值一直是全局名称空间的所有内容

　　内置函数locals（） 当前作用域空间内容，字典格式输出
　　　　反回一个字典，当前位置的所有变量
　　　　可以理解为，所在内存空间中的的所有变量，全局内存即显示所有，局部内存显示当前局部内存里的所有变量，在哪个局部内存里就显示哪个内存里的所有变量。，
　　　　

　　　　　　举例：

　　　　　　　　name = 'alex'
　　　　　　　　age = 1000
　　　　　　　　sex = '男'

　　　　　　　　def func1():
　　　　　　　　name1 = 'oldboy'
　　　　　　　　age = 10000
　　　　　　　　print(globals())
　　　　　　　　print(locals())

　　　　　　　　func1()

改变上层空间的变量值方法

　　不可变数据类型修改上层空间变量值的方法：调用内置函数global、nolocal

　　global作用：（操作全局变量）
　　　　1. 应用并改变一个全局变量。
　　　　2. 在局部作用域声明一个全局变量。

　　　　前提：
　　　　　　在函数取值顺序时有一条，局部空间向全局空间可以引用取值，不能改变取值，否则会报错！

　　　　　　　　举例1：应用并改变一个全局变量。
　　　　　　　　　　count = 1
　　　　　　　　　　def func1():
　　　　　　　　　　global count ###引用并改变一个全局变量不会报错
　　　　　　　　　　count = count + 1
　　　　　　　　　　count = count + 100
　　　　　　　　　　print(count)
　　　　　　　　　　func1()
　　　　　　　　　　print(count)
　　　　　　　　结果：
　　　　　　　　　　102
　　　　　　　　　　102

　　　　　　　　举例2：在局部作用域声明一个全局变量。
　　　　　　　　　　def func1():
　　　　　　　　　　global name ###局部作用域直接声明一个全局变量
　　　　　　　　　　name = 'susi'
　　　　　　　　　　print(name) ###打印局部变量name 结果：susi
　　　　　　　　　　func1()
　　　　　　　　　　print(name) ###打印全局变量name 结果：susi

　　nonlocal作用：（操作局部变量）
　　　　Nonlocal不能操作全局变量，只针对局部变量进行修改。
　　　　在函数嵌套中，函数从内向外依次取值，向上层函数取值时，都只是引用不能改变。想要改变需要借助nolocal进行修改。
　　　　Nonlocal在函数嵌套，多层局部变量，从那层引用的该变量，就从那层开始全部改变。

　　　　　　举例：
　　　　　　　　def func1():
　　　　　　　　count = 1
　　　　　　　　def inner():
　　　　　　　　nonlocal count
　　　　　　　　count = count + 3
　　　　　　　　print(count) ###打印inner函数作用域的count值
　　　　　　　　def inner2():
　　　　　　　　pass
　　　　　　　　inner()
　　　　　　　　print(count) ###打印inner上级函数func1作用域的count值
　　　　　　　　func1()
　　　　　　结果：
　　　　　　　　4
　　　　　　　　4

　　可变的数据类型 list dict set修改上层空间变量值的方法：（不用global nonlocal）

　　　　　　举例：
　　　　　　　　# list = []
　　　　　　　　# def func1():
　　　　　　　　# list.append(666)
　　　　　　　　# func1()
　　　　　　　　# print(list)

　　如果默认参数是一个可变的数据类型，那么他在内存中永远是一个内存地址，一个变都变。

　　　　　　举例：
　　　　　　　　def extendList(val,list=[]):
　　　　　　　　list.append(val)
　　　　　　　　return list ###结束函数反回值是list
　　　　　　　　list1 = extendList(10)
　　　　　　　　print('list1=%s'%list1) 结果：list1=[10]
　　　　　　　　list2 = extendList(123,[])
　　　　　　　　print('list2=%s'%list2) 结果：list2=[123]
　　　　　　　　list3 = extendList('a')
　　　　　　　　print('list3=%s'%list3) 结果：list3=[10, 'a']

　　　　　　　　print('list1=%s'%list1) 结果：list1=[10, 'a']
　　　　　　　　print('list2=%s'%list2) 结果：list2=[123]
　　　　　　　　print('list3=%s'%list3) 结果：list3=[10, 'a']

　　　　　　给函数传参立马得出结果和传完参数统一打印结果，可以看出可变的数据类型，在内存地址是不会改变的。