发帖
翼度科技»论坛 › 编程开发 › python › 查看内容

Python基础globlal nonlocal和闭包函数装饰器语法糖

张吃穿

2

主题

2

帖子

6

积分

新手上路

Rank: 1

积分
6
显示全部楼层
一、global与nonlocal


1、global


  • 在py文件中，一般无法调用函数体内变量名，而global可使函数体代码内的变量名直接在函数体外部调用，条件是在需要调用的代码体中使用global 调用需要的变量名
未使用global情况：
  1. # 在外部绑定一个变量名
  2. name = 'kangkng'
  3. # 定义一个函数体代码
  4. def func():
  5.     # 函数体内部重新绑定一个变量名
  6.     name = 'zhangzhang'
  7. # 调用函数func
  8. func()
  9. # 这时无法打印函数体内部的变量名
  10. print(name)
  11. ------------------------------------------------------------------------ kangkang   
复制代码
使用global情况:
  1. # 在函数体内部使用global时，可在外部直接调用函数内部变量名
  2. name = 'kangkng'
  3. # 定义一个函数体代码
  4. def func():
  5.     # 使用global调用变量名
  6.     global name
  7.     # 函数体内部重新绑定一个变量名
  8.     name = 'zhangzhang'
  9. # 调用函数func
  10. func()
  11. # 外py中打印name
  12. print(name)
  13. ------------------------------------------------------------------------
  14. zhangzhang
复制代码
2、nonlocal


  • 在函数嵌套使用时，通常在父代码体中无法调用子代码中变量名，
而nonlocal的作用是，可以在父代码中直接调用子代码中的变量名，条件是需要在子代码中使用nonlocal 调用需要的变量名
未使用nonlocal情况：
  1. # 定义一个函数体代码
  2. def outer():
  3.     # 绑定一个变量名
  4.     name = 'kangkang'
  5.     # 代码体内部再次定义一段函数体
  6.     def subcoat():
  7.         # 内层中绑定变量名
  8.         name = 'zhangzhang'
  9.     # 在函数外层打印变量名
  10.     print(name)
  11. # 调用外层函数体代码
  12. outer()
  13. -----------------------------------------------------------------------
  14. kangkang
复制代码
使用nonlocal情况：
  1. # 在函数体内部使用global时，可在外部直接调用函数内部变量名
  2. def outer():
  3.     # 函数外层绑定一个变量名
  4.     name = 'kangkang'
  5.     # 代码体内部再次定义一段函数体
  6.     def subcoat():
  7.         # 在函数体内层使用nonlocal，调用变量名
  8.         nonlocal name
  9.         # 内层中绑定变量名
  10.         name = 'zhangzhang'
  11.     # 调用内层函数
  12.     subcoat()
  13.     # 在函数外层打印变量名
  14.     print(name)
  15. # 调用外层函数体代码
  16. outer()   
  17. ----------------------------------------------------------------------
  18. zhangzhang
复制代码
二、函数名的多种用法

引言：
​ 函数名就相当于变量名，只不过函数名绑定的是一段函数体代码，在我们使用这个函数名加括号时就可以调用这段代码体，具体由以下几种用法：
1、当做变量名赋值
  1. def func():
  2.     print('我是func函数体代码')
  3. res = func
  4. print(res())
  5. ------------------------------------------------------------------------
  6. 我是func函数体代码
  7. None
复制代码
2、当作函数的参数
  1. def func():
  2.     print('我是func函数体代码')
  3. def func1(a):
  4.     print('我是func1函数体代码', a)
  5.     a()
  6. func1(func)
  7. ------------------------------------------------------------------------
  8. 我是func1函数体代码 <function func at 0x000001D0C14D6310>
  9. 我是func函数体代码
复制代码
3、当作函数的返回值
  1. def func():
  2.     print('我是func函数体代码')
  3. def func1():
  4.     print('我是func1函数体代码')
  5.     return func
  6. res = func1()
  7. print(res)
  8. res()
  9. ------------------------------------------------------------------------
  10. 我是func1函数体代码
  11. <function func at 0x00000218F95B6310>
  12. 我是func函数体代码
复制代码
4、当作容器类型的数据
  1. def spring():
  2.     print('我是春季,生机盎然')
  3. def summer():
  4.     print('我是夏季，活力四射')
  5. def autumn():
  6.     print('我是秋季，翩翩起舞')
  7. def winter():
  8.     print('我是冬季，大雪纷飞')
  9. while True:
  10.     season_dict = { '1': spring,
  11.                '2': summer,
  12.                '3': autumn,
  13.                '4': winter
  14.                    }
  15.     season_select = input('根据编号，选择您喜欢的季节>>>:').strip()
  16.     if season_select in season_dict:
  17.         season_dict.get(season_select)()
  18.     else:
  19.         print('你选择的编号不存在')
  20. ------------------------------------------------------------------------
复制代码
三、闭包函数


1、什么是闭包函数

  一个函数的返回值是另外一个函数，返回的函数调用父函数内部的变量，如果返回的函数在外部被执行，就产生了闭包

2、闭包函数需满足的条件

满足以下两个条件的就是闭包函数：
条件一：定义在函数内部的函数
条件二：用到了外部函数空间名称中的名子

3、闭包函数的作用

作用：使函数外部能够调用函数内部放入属性和方法
缺点：闭包操作导致整个函数的内部环境被长久保存，占用大量内存

4、闭包函数的实际应用

1.函数内部变量名在外部被访问
  1. def fun1():
  2.     name = 'python'
  3.     def inner():
  4.         print(name)
  5.     return inner
  6. result = fun1()
  7. result()
  8. ------------------------------------------------------------------------
  9. python
复制代码
2.函数体内部函数体代码可以通过外部访问
  1. def fun2():
  2.     def inner():
  3.         print("执行了内部函数inner")
  4.     def all():
  5.         return inner
  6.     return all
  7. result = fun2()
  8. result()()
  9. ------------------------------------------------------------------------
  10. 执行了内部函数inner
复制代码
四、装饰器

​ 当我们需要将一段函数体代码在不改变调用方式和源代码的情况下，需要给这个段代码添加新的功能时，这时候我们就需要给这段代码安装一个装饰器，装饰器是指将这段代码封装在闭包函数内，来达到既能满足上述条件，又能增加新的功能的条件
概念

  • 在不修改被装饰对象源代码和调用方式的情况下给被装饰的对象添加新的功能
本质

  • 并不是一门新的技术，而是由函数参数、名称空间、函数名多种用法、闭包函数组合到一起的效果
口诀

  • 对修改封闭，对扩展开放

1、装饰器推导流程

1、首先定义一段函数体代码，当我们给这段函数传入指定的参数时，他就会暂停一秒，然后运行，使它在运行结束后，能够统计它的运行时间
  1. import time
  2. def index(a， b):
  3.     time.sleep(1)
  4.     print(index，a， b)
复制代码
2、通常，我们只需要在这段代码运行前打印一个时间戳，运行后再次打印一个时间戳，在这段代码运行结束后通过前后时间的插值就能统计出这段代码的运行时间，但这种办法使用起来比较麻烦且只能使用一次
  1. 方法一：
  2.     import time
  3.     def index(a, b):
  4.         start = time.time()
  5.         time.sleep(1)
  6.         print(index, a, b)
  7.         end = time.time()
  8.         print(end - start)
  9.     index(1,2)
  10. 方式二：
  11.     import time
  12.     def index(a, b):
  13.         time.sleep(1)
  14.         print(index, a, b)
  15.     start = time.time()
  16.     index(1,2)
  17.     end = time.time()
  18.     print(end - start)
复制代码
3、通过上述方法的方式二，我们可以得出将函数名包裹在统计时间功能代码内，这样在调用时相对便捷，进一步思考，若将这段代码使用函数封包，那样在调用时就可以更为便捷，在以后统计该代码时，只需要调用封包这段代码的函数名就可以直接统计这段代码的运行时间
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5. def time_():
  6.     start = time.time()
  7.     index()
  8.     end = time.time()
  9.     print(end - start)
  10. time_()
  11. ------------------------------------------------------------------------
  12. Traceback (most recent call last):
  13.   File "D:/pytcharm项目文件路径/38/11.py", line 297, in <module>
  14.     time_()
  15.   File "D:/pytcharm项目文件路径/38/11.py", line 293, in time_
  16.     index()
  17. TypeError: index() missing 2 required positional arguments: 'a' and 'b'
复制代码
4、虽然这种方式可以行得通，但只能针对没有参数的函数体代码，若这段代码需要传参者无法运行，并直接报错。再次进一步思考，只需要将封包的这段函数设置为有参函数就可解决这个问题
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5. def core(a,b):
  6.     start = time.time()
  7.     index(a, b)
  8.     end = time.time()
  9.     print(end - start)
  10. core(1, 2)
  11. ------------------------------------------------------------------------
  12. <function index at 0x000001F4A0026310> 1 2
  13. 1.0047826766967773
复制代码
5、由上推导可看出，虽然此功能可以更为便捷的统计代码执行时间，但若是源代码的参数需要修改则封包它的参数也需要修改，这时我们可联想到将参数修改为可变长参数，就不会出现这个问题
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5. def core(*args,**kwargs):
  6.     start = time.time()
  7.     index(*args, **kwargs)
  8.     end = time.time()
  9.     print(end - start)
  10. core(1,2)
  11. ------------------------------------------------------------------------
  12. <function index at 0x000002ECDD4E6310> 1 2
  13. 1.004744529724121
复制代码
6、这样无论源代码参数如何修改，我们都可以进行传参，虽然这个问题解决了，但考虑使用的广泛性，若有其他函数体也需要用到这个功能时，还需要重新修改封包内代码，这时，我们可以使用闭包的方式来满足这个条件
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5. def func(x, y, z):
  6.     time.sleep(2)
  7.     print(func, x, y, z)
  8. def outer(index):
  9.     def core(*args, **kwargs):
  10.         start = time.time()
  11.         index(*args, **kwargs)
  12.         end = time.time()
  13.         print(end - start)
  14.     return core
  15. res = outer(func)
  16. res(1, 2, 3)
  17. ------------------------------------------------------------------------
  18. <function func at 0x0000018C23686670> 1 2 3
  19. 2.00856614112854
复制代码
7、通过将源代码函数名放至闭包函数参数内，就可以达到可以调动任何函数体代码都可以执行此功能的方法，但并未满足闭包函数的条件，源代码的调用方式改变了，这时我们可以通过将原函数体代码赋值的方式来达到调用方式和源代码都未改变的情况下来增加此功能
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5. def func(x, y, z):
  6.     time.sleep(2)
  7.     print(func, x, y, z)
  8. def outer(index):
  9.     def core(*args, **kwargs):
  10.         start = time.time()
  11.         index(*args, **kwargs)
  12.         end = time.time()
  13.         print(end - start)
  14.     return core
  15. index = outer(index)
  16. index(1,2)
  17. func = outer(func)
  18. func(1, 2, 3)
  19. ------------------------------------------------------------------------
  20. <function outer.<locals>.core at 0x0000026C17F58280> 1 2
  21. 1.004807710647583
  22. <function outer.<locals>.core at 0x0000026C17F58940> 1 2 3
  23. 2.0077626705169678
复制代码
8、虽然上述推导过程都已满足装饰器条件，但是考虑到源代码有返回值的情况，我们没有并没有获取，这时在进一步推导，可在装饰器函数内部调用源代码函数名的位置设置一个变量名用于接收返回值，传给装饰器底层return用于接收即可解决这个问题
  1. import time
  2. def index(a, b):
  3.     time.sleep(1)
  4.     print(index, a, b)
  5.     return 'index'
  6. def func(x, y, z):
  7.     time.sleep(2)
  8.     print(func, x, y, z)
  9.     return 'func'
  10. def outer(index):
  11.     def core(*args, **kwargs):
  12.         start = time.time()
  13.         res = index(*args, **kwargs)
  14.         end = time.time()
  15.         print(end - start)
  16.         return res
  17.     return core
  18. index = outer(index)
  19. res = index(1,2)
  20. print(res)
  21. func = outer(func)
  22. res = func(1, 2, 3)
  23. print(res)
  24. ------------------------------------------------------------------------
  25. <function outer.<locals>.core at 0x0000020C50A78280> 1 2
  26. 1.0050580501556396
  27. index
  28. <function outer.<locals>.core at 0x0000020C50A78940> 1 2 3
  29. 2.0094454288482666
  30. func
复制代码
2、装饰器语法糖

什么是装饰器语法糖
当我们使用装饰器调用被装饰的函数体代码时，总是需要在调用前通过赋值的方式来调用，这样的方式相对比较麻烦，这时我们就可以用到装饰器语法糖来节省时间和代码
语法糖的使用方法和条件
用法：在源代码函数体上方使用@加装饰器函数名
条件：源代码需在装饰器下方
具体用法
  1. import time
  2. def outer(index):
  3.     def core(*args, **kwargs):
  4.         start = time.time()
  5.         res = index(*args, **kwargs)
  6.         end = time.time()
  7.         print(end - start)
  8.         return res
  9.     return core
  10. @outer
  11. def index(a, b):
  12.     time.sleep(1)
  13.     print(index, a, b)
  14.     return 'index'
  15. index(1,2)
复制代码
3、装饰器模板
  1. def outer(func):
  2.     def inner(*args, **kwargs):
  3.         # 执行被装饰对象之前可以做的额外操作
  4.         res = func(*args, **kwargs)
  5.         # 执行被装饰对象之后可以做的额外操作
  6.         return res
  7.     return inner
复制代码
以上就是Python基础globlal nonlocal和闭包函数装饰器语法糖的详细内容，更多关于Python基础globlal nonlocal的资料请关注脚本之家其它相关文章！

来源:https://www.jb51.net/article/266720.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

上一篇: Python基础之文件操作及光标移动详解

下一篇: Python基础第三方模块requests openpyxl

发表于 2023-1-3 16:12:56

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4