locals和globals，函数的嵌套，nonlocal，闭包函数及特点以及匿名函数---day11

1.locals和globals

1.1locals  获取当前作用域中的所有内容

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

locals 如果在函数外,调用locals(),获取打印的是打印之前的所有变量,返回字典,全局空间作用域 locals 如果在函数内,调用locals(),获取的是调用之前的所有变量,返回字典,局部空间作用域   #例子1   a = 1 b = 2 res = locals() c = 3 print(res)  #打印前面所有的变量的值，返回一个字典 d = 4  #不打印   a = 1 def outer():     def inner():         return 'www'     inner() res = locals() b = 2 c = 4 print(res) #打印前面所有全局变量，返回一个字典 d = 5  #不打印   #例子2 a = 1 def func():     b = 2     #这个是调用之前的局部变量     res =locals()  #这个是调用     c = 3     print(res)#打印的是调用之前的局部内的变量是b = 2，返回字典形式{'b':2},     d = 4 func()     a = 1 def outer():     b = 2  #不会打印外函数的局部变量b=2     def inner():         c = 4  #内函数的局部变量         e = 6  #内函数的局部变量         res = locals() 调用         d =4         print(res) # 打印内函数的局部变量返回{'c':4,'e':6}     inner() outer()

　　

1.2globals 获取全局作用域的所有内容

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

globals 如果在函数外，调用globals()，获取打印的是打印之前的所有全局变量，返回字典，全局空间作用域 globals 如果在函数内，调用globals()，获取打印的是调用之前的所有全局变量，返回字典，全局空间作用域   #例子3 a = 5 b = 6 res = globals() c = 7 print(res) #打印之前的所有变量 返回字典形式 d = 8 #不打印 该变量在打印之后   a = 1 def outer():     def inner():         return 'www'     inner() res = globals() b = 2 c = 4 print(res) #打印前面所有全局变量，返回一个字典 d = 5  #不打印    #例子4  a = 10  #全局变量  def func():     b = 11     c =12     res = globals()  #调用     d = 13     print(res)#打印出的是调用之前的所有全局变量{'a':10,'ff':33} ff = 33  #全局变量 func()   #执行函数 zz = 50  #不打印，因为这是在整个func函数全部执行完才定义的全局全局变量

　　

1.3globals返回的是系统的字典

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#1.正常方式定义变量 zhangsan = '112233'     #2.通过系统的全局字典添加键值对，可以动态创建全局变量 dic =globals() print(dic) ##{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DEA2B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/pythonproject/python_all/ceshi/day_01.py', '__cached__': None, 'dic': {...}}     # 传递字符串 ，创建一个变量  k = 'liuwei'  dic[k] = '刘伟'  #键值对添加'liuwei':'刘伟'  print(liuwei)  #通过键取值     #3.批量创建全局变量 在函数中 def func():     dic = globals()     for i in range(1,6):         dic['p%d'%(i)] = i  #p1 p2 p3 p4 p5 p6 func() print(p1)  #1 print(p2)  #2 print(p3)  #3 print(p4)  #4 print(p5)  #5

　　

2.函数的嵌套

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

函数的嵌套：     嵌套在函数的外边叫作外函数     嵌套在函数的里面叫作内函数 def outer():     def inner():         print('我是inner 函数')     inner()       outer()     #inner() (1)内部函数可以直接在函数外部调用吗？  不可以 (2)调用外部函数后，内部函数可以在函数外部调用吗？ 不可以 (3)内部函数可以在函数内部调用吗？  可以 (4)内部函数在函数内部调用时，是否由先手顺序？ 有(必须先定义再调用)   #最外层outer，中间层inner，最里层smaller，调用smaller，执行里面的代码 def outer():     def inner():         def smaller():             print(id)  #找的是内置的             print('我是smaller函数')         smaller()     inner() outer()   # LEGB 原则(即就近找变量的原则) #找寻变量的调用顺序采用LEGB原则(就近原则) ''' B —— Builtin(Python) python内置模块的命名空间(内键作用域) G —— Global(module)  函数外部所在的命名空间  (全局作用域) E —— Enclosing function locals；外部嵌套函数的作用域 (嵌套作用域) L —— Local(function)； 当前函数内的作用域    (局部作用域) 依据就近原则，从下往上 从里向外，依次寻找 '''

　　

3.nonlocal

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

nonlocal 关键字 用来更改局部变量 nonlocal  遵循LEGB原则 (1)nonlocal  专门用来修改当前作用域上一级的局部变量 (2)如果上一级找不到，那么就继续向上寻找 (3)全部找不到，直接报错 (不涉及全局变量)   #(1) nonlocal 专门用来修改当前作用域上一级的局部变量 def outer():     a = 10     def inner():         nonlocal a         a = 20     inner()     print(a)  #a = 20 outer()   #(2) 如果上一级找不到，那么久继续向上寻找 '''nonlocal 只能修改局部变量''' def outer():     a = 41     def inner():         def smaller():             nonlocal a             a = 42             print(a)         smaller()         print(a)  #42     inner()     print(a) #42 outer()   #(3) 全部找不到，直接报错 a = 41 def outer():     def inner():         def smaller():             nonlocal a  #找不到局部变量a  报错             print(a)         smaller()         print(a)     inner()     print(a) outer()     #(4) 不使用nonlocal 是否可以修改局部变量呢? def outer():     lst = [1,2,3]     def inner():         lst[-1] = 52     inner()     print(lst) outer()   #当局部中有可变数据类型时，可以不使用nonlocal来修改全局变量 def outer():     dic = {'a'1,'b':2}     def inner():         dic['a'] = 5     inner()     print(dicvar) outer()     #注意点  两者之间的区别 #第一种  这种是在函数内修改局部变量 def outer():     a = 10     def inner():         nonlocal a         a = 2         print(a)  #a = 2     inner()     print(a)  # a = 2 outer() #第二种  这种是在函数内自己又定义了一个变量a，与外函数的局部变量不是同一个 def outer():     a = 10     def inner():         a = 2         print(a)  # a = 2     inner()     print(a)  # a = 10 outer()

　　

4.闭包函数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

闭包函数： 闭包函数：     内函数使用了外函数的局部变量     外函数将内函数返回出来的过程 叫作闭包     里面的内函数叫作闭包函数 #(1) 闭包函数用法 def wz_family():     father = '马云'     def mayun_hobby():         print('{0}不在乎钱'.format{father})     return mayun_hobby # res = mayun_hobby  <====> res() = mayun_hobby() res = wz_family() print(res)  #打印出来的是一个函数内存地址 res()  #加括号相当于调用函数 解析： wz_family调用函数拿一个变量res接收，返回mayun_hobby,res = mayun_hobby, 内部函数mayun_hobby需要mayun_hobby加()执行，就可以用res()执行内部函数   #(2) 升级 def liuwei_familt():     father = '刘德华'     jiejie = '刘亦菲'     meimei = '杨颖'     money = 1000           def jiejie_hobby():         nonlocal money         money  -= 600         print('穷的没钱了,还剩%s元'%(money))               def meimei_hobby():         nonlocal money         money -=200         print('我比你还穷，只剩下%s元'%(money))               def big_master():         return [jiejie_hobby,meimei_hobby]               return big_master       func = liuwei_familt()  #返回的big_master print(func) res = func() #相当于调用了big_master() print(res)  #返回回来的是[jiejie_hobby,meimei_hobby]       #分别获取姐姐，妹妹这两个函数 jiejie = res[0] jiejie() #相当于调用jiejie_hobby函数 meimei =res[1] meimei()#相当于调用meimei_hobby函数         # ### 获取闭包函数使用的变量 __closure__,cell_contents（了解） tup = func.__closure__ print(tup) #(<cell at 0x0000000001E15618: function object at 0x0000000001E99AE8>, # <cell at 0x0000000001E15678: function object at 0x0000000001E99B70>)   #cell_contents  #功能获取单元对象里面的内容 jiejie = tup[0].cell_contents meimei = tup[1].cell_contents print(jiejie) #<function weifuqiang_family.<locals>.jiejie_hobby at 0x0000000001E99AE8> jiejie() meimei()

　　

5.闭包特点

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

闭包特点：   内函数使用了外函数的局部变量，该局部变量与内函数发生绑定，延长该变量的生命周期 #函数的定义处 def outer(var):  #var = 5     def inner(num):         return num+var #num = 4     return inner       # 函数的调用处 func = outer(5) res = func(4) # ==> inner() print(res) 解析： 1.实参5 和形参var一一对应  进行接收val = 5 因为内函数inner 和 val进行绑定，延长了val变量的生命周期，不释放 func = outer(5)  <====> func = inner 2,实参4  和形参num一一对应 进行接收num= 4 return num + val <===> 4+5 = 9   闭包的意义 闭包可以优先使用外函数的局部变量 局部变量在函数外部不能被直接使用 对局部变量实现了保护的作用，外部无法访问   #模拟鼠标点击操作   #方法一 click_num = 0 def click_func():     global click_num     click_num +=1     print(click_num)       click_func()  #1 click_func()  #2 click_func()  #3 click_num = 100  #在函数内部声明click_num为全局变量并修改，所以在函数外部也可以修改这个全局变量 click_func()  #101   #方法二 def outer():     click_num = 0     def inner():         nonlocal click_num  #定义click_num是一个局部变量，在函数局部内有这个变量         click_num +=1         print(click_num)     return inner #click_func = inner click_func = outer() click_func()  #1 click_func()  #2 click_func()  #3 click_num = 100  #在函数外部不能修改局部内变量 click_func()  #4 解析： 闭包函数： 首先外函数的局部变量click_num为0，内函数想修改外函数的局部变量就需要用nonlocal声明 然后才能修改 click_num = 100在函数外部不能修改函数内部的局部变量

　　

6.匿名函数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

匿名函数 lambda 表达式 用一句话来表达只有返回值的函数  特点：简洁，高效，方便 语法结构：     lanbda 参数：返回值   #(1)  无参的lambda表达式 def func():     return '我是大哥'   #改成lambda表达式 func = lambda : '我是大哥' res  =  func() print(res)   #(2) 有残的lambda 表达式 def func(n):     return type(n)       #用lambda表达式 func = lambda n : type(n) res =func() print(res)   #(3) 带有判断条件的lambda表达式 def func(n):     if n%2 == 0:         return '偶数'     else:         return '奇数'   三元(三目)运算符 真值 if 条件表达式 else 假值 如果条件表达式成立 为真 返回真值 如果条件表达式不成立 为假 返回假值   n = 20 res '偶数' if n%2 == 0 else '奇数' print(res)   #lambda表达式 func = lambda n : '偶数' if n %2==0 else '奇数' res = func() print(res)   #练习 def func(x,y):     if x>y:         return x     else:         return y   func = lambda x,y : x if x>y else y res = func(22,5) print(res)

　　

总结：今天主要讲了以下个点，locals和globals的用法，函数的嵌套，nonlocal，闭包函数及其特点以及匿名函数

locals：获取当前作用域中的所有内容

locals 如果在函数外，调用locals(),获取的是打印之前的所有变量，返回字典，全局空间作用域

locals 如果在函数内，调用locals(),获取的是调用之前的所有变量，返回字典，局部空间作用域

globals  获取全局作用域的所有内容

globals 如果在函数外，调用globals(),获取的是打印之前的所有全局变量，返回字典，全局空间作用域

globals 如果在函数内，调用globals(),获取的是调用之前的所有全局变量，返回字典，全局空间作用域

用globals可以通过系统的全局字典添加键值对，可以动态创建全局变量,也可以批量创建全局变量

函数的嵌套：

嵌套在函数的外边叫作外函数

嵌套在函数的里面叫作内函数

内部函数不可以直接在函数外部调用

调用外部函数后，内部函数不可以在函数外部调用

内部函数可以在函数内部调用

内部函数在函数内部调用时，有先后顺序(必须先定义再调用)

还讲了LEGB原则就是就近变量的原则，从下往上，从里向外

nonlocal 通用遵循LEGB原则：

专门用来修改当前作用域上一级的局部变量

如果上一级找不到，那么就继续向上寻找

全部找不到，直接报错 (不涉及全局变量)

不使用nonlocal可以修改局部变量，当外函数的局部变量是可变数据类型时，内函数可以不用nonlocal来修改局部变量

闭包函数：

内函数使用了外函数的局部变量

外函数将内函数返回出来的过程 叫作闭包

里面的内函数叫作闭包函数

还讲了两个获取闭包函数的函数，__closure__,cell_contents

闭包的特点：

内函数使用了外函数的局部变量 该局部变量与内函数发生绑定 延长该变量的生命周期

闭包可以优先使用外函数的局部变量
局部变量在函数外部不能被直接使用
对局部变量实现了保护的作用，外部无法访问

匿名函数：用一句话来表达只有返回值的函数  特点：简洁，高效，方便

语法结构：
lanbda 参数：返回值

三元运算符：

真值 if 条件表达式 else 假值
如果条件表达式成立 为真 返回真值
如果条件表达式不成立 为假 返回假值

 

__EOF__

本文作者：404 Not Found
本文链接：https://www.cnblogs.com/weiweivip666/p/12886126.html
关于博主：可能又在睡觉
版权声明：转载请注明出处
声援博主：如果看到我睡觉请喊我去学习