python开发函数进阶：命名空间，作用域，函数的本质，闭包，内置方法（globales）

Posted 2020-09-30

一，命名空间

#局部命名空间
#全局命名空间
#内置命名空间

#三者的顺序
#加载顺序 硬盘上——内存里
#内置-->全局(从上到下顺序加载进来的)-->局部（调用的时候加载）

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #全局命名空间
 5 a = 5
 6 b = 8
 7 #局部命名空间（函数）
 8 def my_max():
 9     c = a if a > b else b
10     return c
11 m = my_max()
12 print(m)

 

二，作用域

#命名空间+作用域是分不开的
#两种
#全局作用域：全局命名空间、内置命名空间
#局部作用域：局部命名空间

#站在全局看：
#使用名字:
#如果全局有：用全局的
#如果全局没有：用内置的

#为什么要有作用域的概念：
#为了函数内的变量不会影响到全局

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def max(a,b):
 5     a = 10  #局部
 6     b = 20
 7 a = 2    #全局
 8 b = 3    #
 9 max(30,50)
10 print(a,b)

 总结：

#小范围的可以用大范围的
#但是大范围的不能用小范围的
#在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的
#如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。
#如果都没有，报错

三，作用域链,小范围的可以用大范围的

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 x = 1
 5 def heihei():
 6     def inner1():
 7         def inner2():
 8             print(x)
 9         inner2()
10     inner1()
11 heihei()

 

四，函数的嵌套

#为了保护内部函数，确定内部函数只能在外部函数中被调用

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #函数嵌套
 5 def animal():
 6     def tiger():
 7         print(‘bark‘)
 8     print(‘eat‘)
 9     tiger()
10 animal()
11 
12 #函数嵌套使用
13 def f1():
14     print(a)  #无法获取f2的a的值，注意执行顺序
15     print(‘f1‘)
16 def f2():
17     a = 10
18     f1()
19 f2()

 

五，函数名的本质就是内存地址

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def func():
 5     print(‘func‘)
 6 print(func)   #函数func内存地址
 7 f = func    #就是函数的内存地址
 8 print(f)   #函数func内存地址
 9 f()  #执行代码
10 #############
11 l = [f]     #还是函数内存地址
12 print(l)
13 l[0] == f  #用索引取值
14 l[0]()
15 
16 #可以用作函数的参数
17 def func():
18     print(‘func‘)
19 def func2(f):
20     print(f)   #func的内存地址
21     f()        #执行func函数
22     print(‘func2‘)
23 func2(func)
24 
25 #可以作为函数的返回值
26 def func():
27     print(‘func‘)
28 def func2(f):   #1 接收func函数的内存地址
29     print(‘func2‘)
30     return f    #2 返回给fu函数func函数的内存地址
31 fu = func2(func)
32 fu()    #3  执行函数func
33 
34 #如果我想在全局使用内部的函数

 

六，闭包

#1.闭 ：内部的函数
#2.包 ：包含了对外部函数作用域中变量的引用

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #闭包函数：内部函数，包含了对外部作用域中变量的引用
 5 def hei():
 6     x = 20
 7     def inner():
 8         ‘‘‘
 9         闭包函数
10         ‘‘‘
11         print(x)
12 
13 #闭包的常用形式
14 def hei():
15     x = 20
16     def inner():
17         print(x)  #局部的
18     return inner
19 i = hei()
20 i()  #全局
21 
22 
23 #闭包的例子，爬网页，函数执行完就会消失，但是在调用的时候又会打开，闭包解决了这个问题
24 from urllib.request import urlopen
25 # def index():
26 #     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
27 #     return urlopen(url).read()
28 # index()
29 
30 def index():
31     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
32     def inner():
33         return urlopen(url).read()
34     print(inner.__closure__)
35     return inner
36 # u = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
37 get = index()
38 print(get())

 

7，内置方法

#locals,globals方法，只有globals方法，作用是局部可以更改全局的变量

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 a = 20
 5 b = 50
 6 def haha():
 7     x = 1
 8     y = 2
 9     print(globals())  #全局作用域中的名字
10     print(locals())   #局部作用域中的名字
11 haha()
12 print(globals())  #全局作用域中的名字
13 print(locals())   #全局的局部还是全局

nonlocal
# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 def f():
 5     a = 3
 6     def f1():
 7         a = 1
 8         def f2():
 9             nonlocal a   #可以将上一层的变量更改赋值
10             a = 2
11         f2()
12         print(‘a in f1 : ‘, a)    #此时a是内部函数的a
13     f1()
14     print(‘a in f : ‘,a)    #此时a是局部函数的a
15 f()
16 #a in f1 :  2
17 #a in f :  3