zoukankan      html  css  js  c++  java

  • 装饰器

    1. 今日内容大纲

      1. 90。自我。

      2. 调整自己，适当听取一些其他人的意见。

      3. 承受压力的能力一定要有所提高。

    2. 昨天内容回顾以及作业讲解

      1. 匿名函数：一句话函数。 多于内置函数，列表推导式结合。

      2. 内置函数： *** 加key的。min，max，sorted，map，reduce，filter

      3. 闭包：

        1. 内层函数对外层函数非全局变量的使用。

        2. 一定要存在嵌套函数中。

        3. 作用：保证数据安全。自由变量不会再内存中消失，而且全局还引用不到。

         

    3. 今日内容

      1. 开放封闭原则：

         
        1 装饰器：装饰，装修，房子就可以住，如果装修，不影响你住，而且体验更加，让你生活中增加了很多功能：洗澡，看电视，沙发。
2  器：工具。
3  开放封闭原则：
4  开放：对代码的拓展开放的， 更新地图，加新枪，等等。
5  封闭：对源码的修改是封闭的。闪躲用q。就是一个功能，一个函数。 别人赤手空拳打你，用机枪扫你，扔雷.....这个功能不会改变。
6  ​
7  装饰器：完全遵循开放封闭原则。
8  装饰器： 在不改变原函数的代码以及调用方式的前提下，为其增加新的功能。
9  装饰器就是一个函数。

      2. 装饰器的初识：

        • 版本一： 大壮 写一些代码测试一下index函数的执行效率。

         ​
         1  import time
 2  # def index():
 3  #     '''有很多代码.....'''
 4  #     time.sleep(2) # 模拟的网络延迟或者代码效率
 5  #     print('欢迎登录博客园首页')
 6  #
 7  # def dariy():
 8  #     '''有很多代码.....'''
 9  #     time.sleep(3) # 模拟的网络延迟或者代码效率
10  #     print('欢迎登录日记页面')
11  ​
12  # print(time.time())  # 格林威治时间。
13  # print(111)
14  # time.sleep(3)
15  # print(222)
16  # 版本一有问题： 如果测试别人的代码，必须重新赋值粘贴。
17  # start_time = time.time()
18  # index()
19  # end_time = time.time()
20  # print(end_time-start_time)
21  #
22  # start_time = time.time()
23  # dariy()
24  # end_time = time.time()
25  # print(end_time-start_time)
26  #
27  #
28  # start_time = time.time()
29  # # dariy()
30  # end_time = time.time()
31  # print(end_time-start_time)
32  ​

        • 版本二：利用函数，解决代码重复使用的问题

           1  import time
 2  def index():
 3      '''有很多代码.....'''
 4      time.sleep(2) # 模拟的网络延迟或者代码效率
 5      print('欢迎登录博客园首页')
 6  # index()
 7  def dariy():
 8      '''有很多代码.....'''
 9      time.sleep(3) # 模拟的网络延迟或者代码效率
10      print('欢迎登录日记页面')
11  ​
12  def timmer(f):  # f= index
13      start_time = time.time()
14      f()  # index()
15      end_time = time.time()
16      print(f'测试本函数的执行效率{end_time-start_time}')
17  timmer(index)
18  ​
19  版本二还是有问题： 原来index函数源码没有变化，给原函数添加了一个新的功能测试原函数的执行效率的功能。
20  满足开放封闭原则么？原函数的调用方式改变了。
21  ​
          ​

        • 版本三：不能改变原函数的调用方式。

           1  # import time
 2  # def index():
 3  #     '''有很多代码.....'''
 4  #     time.sleep(2) # 模拟的网络延迟或者代码效率
 5  #     print('欢迎登录博客园首页')
 6  #
 7  # def timmer(f):  # f = index  (funciton index123)
 8  #     def inner():  # inner :(funciton inner123)
 9  #         start_time = time.time()
10  #         f()  # index() (funciton index123)
11  #         end_time = time.time()
12  #         print(f'测试本函数的执行效率{end_time-start_time}')
13  #     return inner  # (funciton inner123)
14  # timmer(index)  # index()
15  # ret = timmer(index)  # inner
16  # ret()  # inner()
17  # index = timmer(index)  # inner (funciton inner123)
18  # index()  # inner()
19  # def func():
20  #     print('in func')
21  #
22  # def func1():
23  #     print('in func1')
24  #
25  # # func()
26  # # func1()
27  # func()
28  # func = 666
29  # func(0)
           ​

        • 版本四：具体研究

           1  import time
 2  def index():
 3      '''有很多代码.....'''
 4      time.sleep(2) # 模拟的网络延迟或者代码效率
 5      print('欢迎登录博客园首页')
 6  ​
 7  def timmer(f):
 8      f = index
 9      # f = <function index at 0x0000023BA3E8A268>
10      def inner():
11          start_time = time.time()
12          f()
13          end_time = time.time()
14          print(f'测试本函数的执行效率{end_time-start_time}')
15      return inner
16  ​
17  index = timmer(index)
18  index()

        • 版本五：python做了一个优化；提出了一个语法糖的概念。 标准版的装饰器

           1  import time
 2  # timmer装饰器
 3  def timmer(f):
 4      def inner():
 5          start_time = time.time()
 6          f()
 7          end_time = time.time()
 8          print(f'测试本函数的执行效率{end_time-start_time}')
 9      return inner
10  ​
11  # @timmer # index = timmer(index)
12  def index():
13      '''有很多代码.....'''
14      time.sleep(0.6) # 模拟的网络延迟或者代码效率
15      print('欢迎登录博客园首页')
16      return 666
17  ret = index()
18  print(ret)
19  ​
20  def dariy():
21      '''有很多代码.....'''
22      time.sleep(3) # 模拟的网络延迟或者代码效率
23      print('欢迎登录日记页面')
24  dariy()
25  # index = timmer(index)
26  # index()
27  # dariy = timmer(dariy)  @timmer
28  dariy()
29  ​
           ​

        • 版本六：被装饰函数带返回值

           ​
           1  import time
 2  # timmer装饰器
 3  def timmer(f):
 4      # f = index
 5      def inner():
 6          start_time = time.time()
 7          # print(f'这是个f():{f()}!!!') # index()
 8          r = f()
 9          end_time = time.time()
10          print(f'测试本函数的执行效率{end_time-start_time}')
11          return r
12      return inner
13  ​
14  @timmer # index = timmer(index)
15  def index():
16      '''有很多代码.....'''
17      time.sleep(0.6) # 模拟的网络延迟或者代码效率
18      print('欢迎登录博客园首页')
19      return 666
20  # 加上装饰器不应该改变原函数的返回值，所以666 应该返回给我下面的ret，
21  # 但是下面的这个ret实际接收的是inner函数的返回值，而666返回给的是装饰器里面的
22  # f() 也就是 r,我们现在要解决的问题就是将r给inner的返回值。
23  ret = index()  # inner()
24  print(ret)
           ​

        • 版本七：被装饰函数带参数

           1  import time
 2  # timmer装饰器
 3  def timmer(f):
 4      # f = index
 5      def inner(*args,**kwargs):
 6          #  函数的定义：* 聚合  args = ('李舒淇',18)
 7          start_time = time.time()
 8          # print(f'这是个f():{f()}!!!') # index()
 9          r = f(*args,**kwargs)
10          # 函数的执行：* 打散：f(*args) --> f(*('李舒淇',18))  --> f('李舒淇',18)
11          end_time = time.time()
12          print(f'测试本函数的执行效率{end_time-start_time}')
13          return r
14      return inner
15  ​
16  @timmer # index = timmer(index)
17  def index(name):
18      '''有很多代码.....'''
19      time.sleep(0.6) # 模拟的网络延迟或者代码效率
20      print(f'欢迎{name}登录博客园首页')
21      return 666
22  index('纳钦')  # inner('纳钦')
23  ​
24  @timmer
25  def dariy(name,age):
26      '''有很多代码.....'''
27      time.sleep(0.5) # 模拟的网络延迟或者代码效率
28      print(f'欢迎{age}岁{name}登录日记页面')
29  dariy('李舒淇',18)  # inner('李舒淇',18)
           ​
          1 标准版的装饰器；
2 
3 def wrapper(f):
4     def inner(*args,**kwargs):
5         '''添加额外的功能：执行被装饰函数之前的操作'''
6         ret = f(*args,**kwargs)
7         ''''添加额外的功能：执行被装饰函数之后的操作'''
8         return ret
9     return inner

      3. 装饰器的应用

         1 # 装饰器的应用：登录认证
 2 # 这周的周末作业：模拟博客园登录的作业。装饰器的认证功能。
 3 
 4 
 5 
 6 def login():
 7     pass
 8 
 9 
10 def register():
11     pass
12 
13 
14 status_dict = {
15     'username': None,
16     'status': False,
17 }
18 
19 def auth(f):
20     '''
21     你的装饰器完成：访问被装饰函数之前，写一个三次登录认证的功能。
22     登录成功：让其访问被装饰得函数，登录没有成功，不让访问。
23     :param f:
24     :return:
25     '''
26     def inner(*args,**kwargs):
27         '''访问函数之前的操作，功能'''
28         if status_dict['status']:
29             ret = f(*args,**kwargs)
30             '''访问函数之后的操作，功能'''
31             return ret
32         else:
33             username = input('请输入用户名').strip()
34             password = input('请输入密码').strip()
35             if username == 'taibai' and password == '123':
36                 print('登录成功')
37                 status_dict['username'] = username
38                 status_dict['status'] = True
39                 ret = f(*args, **kwargs)
40                 return ret
41             else:
42                 print('登录失败')
43     return inner
44 @auth  # article = auth(article)
45 def article():
46     print('欢迎访问文章页面')
47 @auth
48 def comment():
49     print('欢迎访问评论页面')
50 @auth
51 def dariy():
52     print('欢迎访问日记页面')
53 
54 article()  # inner()
55 comment()  #inner()
56 dariy()
57

    4. 今日总结

    5. 预习内容

    预习内容我会以md文件发到群里。

     
  • 相关阅读:
    内部类
    java的静态方法多态和匿名对象
    java的重载 和重写
    java多态成员的特点
    java 接口的概念
    linux时间修改-hwclock和date
    mysql配置主从复制和常见问题
    mysql日志种类、二进制日志模式、mysqlbinlog解析二进制日志
    mysql主从复制介绍
    mysql备份与还原-mysqldump备份、mysql与source还原
  • 原文地址：https://www.cnblogs.com/zhangxiangning/p/10220947.html
Copyright © 2011-2022 走看看