目录
一、python内部的原理
二、命名空间
三、作用域
四、global关键字、nonlocal关键字
五、函数名的本质
六、闭包
七、总结
一、python内部的原理
Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读如内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。
二、命名空间
1 >>> import this
2 The Zen of Python, by Tim Peters
3
4 Beautiful is better than ugly.
5 Explicit is better than implicit.
6 Simple is better than complex.
7 Complex is better than complicated.
8 Flat is better than nested.
9 Sparse is better than dense.
10 Readability counts.
11 Special cases aren't special enough to break the rules.
12 Although practicality beats purity.
13 Errors should never pass silently.
14 Unless explicitly silenced.
15 In the face of ambiguity, refuse the temptation to guess.
16 There should be one-- and preferably only one --obvious way to do it.
17 Although that way may not be obvious at first unless you're Dutch.
18 Now is better than never.
19 Although never is often better than *right* now.
20 If the implementation is hard to explain, it's a bad idea.
21 If the implementation is easy to explain, it may be a good idea.
22 Namespaces are one honking great idea -- let's do more of those!
在python之禅中提到过：命名空间是一种绝妙的理念，让我们尽情的使用发挥吧！
命名空间一共分为三种：
全局命名空间：创建的存储“变量名与值的关系”的空间叫做全局命名空间
局部命名空间：在函数的运行中开辟的临时的空间叫做局部命名空间
内置命名空间：内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。
三种命名空间之间的加载顺序和取值顺序：
加载顺序：内置命名空间（程序运行前加载）===>全局命名空间（从上到下顺序加载进来的）===>局部命名空间（函数调用的时候加载）
取值顺序：在局部调用：局部命名空间===>全局命名空间===>内置命名空间
在全局调用：全局命名空间===>内置命名空间
使用：
全局不能使用局部的
局部可以使用全局的
综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。
三、作用域
1、作用域就是作用范围
2、命名空间和作用域是分不开的
3、作用域分为两种：
全局作用域：全局命名空间与内置命名空间都属于全局范围
在整个文件的任意位置都能被引用，全局有效
局部作用域：局部命名空间，只能在局部范围内生效
4、站在全局看：
使用命名空间的时候，如果有全局命名空间，用全局命名空间
如果没有全局命名空间，用局部命名空间
5、作用域：为了函数内的变量不会影响到全局
6、globals和locals方法（站在全局看globals is locals）
1 name1 = 'wusir'
2 def func1():
3 name2 = 'laonanhai'
4 print(globals()) # 打印全局变量
5 print(locals()) # 打印局部变量
6 func1()
7 # 输出结果：
8 '''
9 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000028AFAABC128>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/benjamin/python自动化21期/day3/06 函数的进阶.py', '__cached__': None, 'name1': 'wusir', 'func1': <function func1 at 0x0000028AF8EB2F28>}
10 {'name2': 'laonanhai'}
11 '''
四、global关键字、nonlocal关键字
global：
1、声明一个全局变量
2、更改一个全局变量
1 # 1、声明一个全局变量
2 def func1():
3 global name
4 name = 'alex'
5 return
6 func1()
7 print(name)
8
9 # 2、更改一个全局变量
10 name = 'wusir'
11 def func1():
12 global name
13 name = 'alex'
14 return
15 func1()
16 print(name)
ps:对可变数据类型（list,dict,set）可以直接引用不用通过global
1 # 对于可变数据类型的应用举例
2 li = [1,2,3]
3 dic = {'a':'b'}
4
5 def change():
6 li.append('a')
7 dic['q'] = 'g'
8 print(dic)
9 print(li)
10 change()
11 print(li)
12 print(dic)
nonlocal:
1、不能修改全局变量
2、在局部作用域中，对父级作用域（或者更外层作用域，非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。
1 def func1():
2 name1 = 'alex'
3 print('+',name1)
4 def inner():
5 nonlocal name1
6 name1= 'wusir'
7 print('*',name1)
8 def inner1():
9 pass
10 inner()
11 print('%',name1)
12 func1()
13 # 输出结果：
14 '''
15 + alex
16 * wusir
17 % wusir
18 '''
1 def add_b():
2 b = 42
3 def do_global():
4 b = 10
5 print(b)
6 def dd_nonlocal():
7 nonlocal b
8 b = b + 20
9 print(b)
10 dd_nonlocal()
11 print(b)
12 do_global()
13 print(b)
14 add_b()
五、函数名的本质
函数名本质上就是函数的内存地址。
1、可以被引用
1 def func():
2 print('in func')
3
4 f = func
5 print(f)
2、可以被当作容器类型的元素
1 def f1():
2 print('f1')
3
4
5 def f2():
6 print('f2')
7
8
9 def f3():
10 print('f3')
11
12 l = [f1,f2,f3]
13 d = {'f1':f1,'f2':f2,'f3':f3}
14 #调用
15 l[0]()
16 d['f2']()
3、可以当作函数的参数和返回值
1 def f1():
2 print('f1')
3
4 def func1(argv):
5 argv()
6 return argv
7
8 f = func1(f1)
9 f()
第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值
3.可存入变量的实体。
*不明白？那就记住一句话，就当普通变量用
六、闭包
1 def func():
2 name = 'gaodong'
3 def inner():
4 print(name)
5 inner()
6 wrapper()
闭包函数：
内层函数对外层函数非全局变量的引用，叫做闭包。
函数内部定义的函数称为内部函数。
闭包的好处：如果python检测到闭包，他有一个机制，你的局部作用域不会随着函数的结束而结束。
1 name = 'alex'
2 def wrapper(argv):
3 def inner():
4 print(argv)
5 inner()
6 print(inner.__closure__) # cell
7 wrapper(name)
判断闭包函数的方法__closure__
1 #输出的__closure__有cell元素 ：是闭包函数
2 def func():
3 name = 'eva'
4 def inner():
5 print(name)
6 print(inner.__closure__)
7 return inner
8
9 f = func()
10 f()
11
12 #输出的__closure__为None ：不是闭包函数
13 name = 'egon'
14 def func2():
15 def inner():
16 print(name)
17 print(inner.__closure__)
18 return inner
19
20 f2 = func2()
21 f2()
1 def wrapper():
2 money = 1000
3 def func():
4 name = 'eva'
5 def inner():
6 print(name,money)
7 return inner
8 return func
9
10 f = wrapper()
11 i = f()
12 i()
1 from urllib.request import urlopen
2
3 def index():
4 url = "http://www.xiaohua100.cn/index.html"
5 def get():
6 return urlopen(url).read()
7 return get
8
9 xiaohua = index()
10 content = xiaohua()
11 print(content)
七、总结
# 闭包和装饰器
# 闭包的定义 : 内部函数引用外部函数的变量
# 闭包的应用 ：装饰器
练习：
1 def wrapper():
2 def inner():
3 name1 = 'alex'
4 print(name1)
5 inner()
6 wrapper()
7
8 def wrapper():
9 def inner():
10 name1 = 'alex'
11 print(name1)
12 return inner
13 ret = wrapper() # inner
14 ret()
