day4装饰器

时间:2022-01-30 10:50:21

Python装饰器

1.必备

  def foo():

    print(foo)

  <function foo at 0x7f62db093f28>
  >>> foo
  <function foo at 0x7f62db093f28>

  foo是函数,函数体;

  foo()是执行foo函数

def foo():

    print(foo)

  foo = lambda x:x+1

  foo()将执行lambda表达式,而不再是原来的foo函数,这是因为函数foo被重新定义了。

2.需求来了

初创公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:

  ##############基础平台提供的功能如下###############
    def f1():

    print(f1)

  def f2():

    print(f2)

def f3():

    print(f3)

  def f4():

    print(f4)

  ############### 业务部门A 调用基础平台提供的功能 ###############

f1()

  f2()

  f3()

  f4()

  ############### 业务部门B 调用基础平台提供的功能 ###############

f1()

  f2()

  f3()

  f4()

  目前公司有条不紊的进行着,但是,以前基础平台的开发人员在写代码的时候没有关注验证相关的问题,即:基础平台提供的功能可以被任何人使用。现在需要对基础平台的功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。

  老大把工作交给了Low B,他是这么做的:

  跟每个业务部门交涉,每个业务部门自己写代码,调用基础平台功能之前先验证,艾,这样一来,基础平台就不需要进行任何修改了。

  不幸的是,当天Low B就被开除了....

    老大把工作交给了Low BB,他是这么做的:

  只对基础平台的代码进行重构,让N个业务部门无需做任何修改

  ##############基础平台提供的功能如下###############

def f1():

    #验证1

    #验证2

    #验证3

    print(f1)

  def f2():

    #验证1

    #验证2

    #验证3

    print(f2)

  def f3():

    #验证1

    #验证2

    #验证3

    print(f3)

  def f4():

    #验证1

    #验证2

    #验证3

    print(f4)

  ############### 业务部门A 调用基础平台提供的功能 ###############

  f1()

  f2()

  f3()

  f4()

  ############### 业务部门B 调用基础平台提供的功能 ###############  

f1()

  f2()

  f3()

  f4()

  ############### 业务部门调用方法不变,不影响业务部门 ###############  

  过了一周Low BB也被开除了......

  上述代码的重用性太差,而且修改了原代码。

  老大把工作交给了Low BBB,他是这么做的:

  只对基础平台的代码进行重构,其他业务部门无需做任何修改。

  def check_login():

    #验证1

    #验证2

    #验证3

    pass

  def f1():

    check_login()

    print(f1)

  def f2():

    check_login()

    print(f2)

  def f3():

    check_login()

    print(f3)

  def f4():

    check_login()

    print(f4)

  老大看了一下Low BBB的实现,嘴角露出了一丝欣慰的笑,语重心长的跟Low BBB聊了个天:

  老大说:

  写代码要遵循开放封闭的原则,虽然在这个原则是用在面向对象开发,但是也是用与函数式编程,它规定已经实现的功能代码不允许被修改,但可以被扩展,即:

  (1)封闭:以实现的功能代码块

  (2)开放:对扩展开发,可以开发新功能,但尽量不要修改原代码。

  如果将开放封闭原则应用在上述需求中,那么就不允许在函数f1、f2、f3、f4的内部修改代码,老大就被给了Low BBB一个实现方案:

  def w1(func):

    def inner():

      #验证1

      #验证2

      验证3

      return func()

  return inner

  @w1

  def f1():

    print(f1)

  @w1

  def f2():

    print(f2)

  @w1

  def f3():

    print(f3)

  @w1

  def f4():

    print(f4)

  ############### 业务部门调用方法不变,不影响业务部门 ###############

对于上述代码,也是仅仅对基础平台的代码进行了修改,就可以实现在其他人调用函数f1,f2,f3,f4之前都进行[验证]的操作,并且其他部门无需做任何修改。

  Low BBB心惊胆战的问了下,这段代码的内部执行原理是什么呢?

  老大正要生气,突然Low BBB的手机掉到了地上,恰巧屏保就是Low BBB的女朋友照片,老大一看一紧一抖,嘻笑眼开,交定了Low BBB这个朋友。详细的讲解开始了:

单独以f1为例:

  def w1(func):

    def inner():

      #验证1

      #验证2

      #验证3

      return func()

  return inner

  @w1

  def f1():

    print(f1)

  当写完这段代码后(函数未被执行、未被执行、未被执行),Python解释器就会从上到下解释代码,步骤如下:

  (1)def w1(func):   ==>将w1加载到内存,扫描加载到内存。

  (2)@w1

没错,从表面上看解释器仅仅会解释这两句代码,因为函数在没有被调用之前其内部代码不会被执行。

  从表面上看解释器着实会执行这两句,但是@w1这一句代码却大有文章,@函数名是Python的一种语法糖(装饰器)。

如上例@w1内部会执行以下操作:

  (1)执行w1函数,并将@wq下面的函数作为w1函数的参数,即:@w1等价于w1(f1)

  所以,内部就会去执行:

    def inner():

      #验证

      return f1()  #func是参数,此时func等价于f1

    return inner     #返回的inner,inner代表的是函数,非执行函数

  其实就是将原来的f1函数塞进另外以一个函数中

  (2)将执行玩的w1函数返回值赋值给@w1下面的函数的函数名

  w1函数的返回值是:

    def inner():

       #验证

      return f1()  #此处表示原来的f1函数

  然后,将此返回值在重新赋值给f1,即:

  新f1 = def inner:

  #验证

    return f1()

  所以,以后业务部门想要执行f1函数时,就会执行新f1函数,在新f1函数内部先执行验证,再执行原来的f1函数,然后将原来f1函数的返回值返回给了业务调用者。

Low BBB你明白了吗?要是没有明白的话,我晚上去你家帮你解决吧!!!

3.问答时间

问题:被装饰的函数有参数呢?

  一个参数:

  def w1(func):

    def inner(arg):

      #验证1

      #验证2

      #验证3

      return func(arg)

  return inner

  @w1

  def f1(arg):

    print(f1)

  二个参数:

  def w1(func):

    def inner(arg1,arg2)

      #验证1

      #验证2

      #验证3

      return func(arg1,arg2)

    return inner

  @w1

  def f1(arg1,arg2):

    print(f1)

  三个参数:

  def w1(func):

    def inner(arg1,arg2,arg3):

      #验证1

      #验证2

      #验证3

      return func(arg1,arg2,arg3)

  return inner

  @w1

  def f1(arg1,arg2,arg3):

    print(f1)

问题:可以装饰具有处理n个参数的函数的装饰器?

  def w1(func):

    def inner(*args,**kwargs):

      #验证1

      #验证2

      #验证3

      return func(*args,**kwargs)

  return inner

  @w1

  def f1(arg1,arg2,arg3):

    print(f1)

问题:一个函数可以被多个装饰器装饰码?

def w1(func):

    def inner(*args,**kwargs):

      #验证1

      #验证2

      #验证3

      return func(*args,**kwargs)

  return inner  

  def w2(func):

    def inner(*args,**kwargs):

      #验证1

      #验证2

      #验证3

    return func(*args,**kwargs)

  return inner

  @w1

  @w2

  def f1(arg1,arg2,arg3):

    print(f1)

下面有一个例子,需要我们来完成,我们需要设置一个网页后台,当用户登录非主页的时候需要验证,如何实现呢?

  首先,我们先定义好各个模块:

  def login(func):
  #登录验证模块
    print("passed user verification......")
    return func

  def home(name):

  #主页,不需要登录验证
    print("Welcome [%s] to home page." %name)
  def tv(name):

    #TV页面,进来需要验证登录
    print("Welcome [%s] to TV page." %name)
  def movie(name):

    #movie页面,进来需要登录验证
    print("Welcome [%s] to movie page." %name)

  上面代码,我们实现了几个函数体,然后,我们知道,要想让用户进行验证,那么在进入网页的时候要先执行login函数,如何执行函数呢,必须调用函数,调用函数之后有一个返回值,我们知道,要不修改原代码以及方便用户操作,用户只需要输入tv(name)即可,这样就直接调用的是tv模块,因为。我们知道,程序是按照串行的方式执行的。那么,我们可以事先执行login()模块,然后返回一个值。在执行tv函数。

  def login(func):
  #登录验证模块
    print("passed user verification......")
    return func

  def home(name):
    print("Welcome [%s] to home page." %name)
  def tv(name):
    print("Welcome [%s] to TV page." %name)
  def movie(name):
    print("Welcome [%s] to movie page." %name)
  tv = login(tv)
  #把tv当作参数传递给login函数,然后返回tv参数,目的就是为了执行一次验证
  tv("alex")

  运行结果如下:

passed user verification......
  Welcome [alex] to TV page.
  虽然我们完美执行了这个程序。但是这个程序有问题,因为用户调用的时候输入的是tv("alex"),那么在没有调用的时候运行程序会是怎样的:

def login(func):
    #登录验证模块
    print("passed user verification......")
    return func

  def home(name):
    print("Welcome [%s] to home page." %name)
  def tv(name):
    print("Welcome [%s] to TV page." %name)
  def movie(name):
    print("Welcome [%s] to movie page." %name)

  tv = login(tv)
  #把tv当作参数传递给login函数,然后返回tv参数
  #tv("alex")

  运行结果如下:

  passed user verification......

  此时,我们并没有调用主页,但是也提示让用户进行输入验证,这样就没有太多实际意义了,因此要想办法让用户没有调用的时候什么都不打印。

def login(func):
    #登录验证模块
    print("passed user verification......")
    return func

  def home(name):
    print("Welcome [%s] to home page." %name)
  @login
  def tv(name):
    print("Welcome [%s] to TV page." %name)
  def movie(name):
    print("Welcome [%s] to movie page." %name)

  #tv = login(tv)
  #把tv当作参数传递给login函数,然后返回tv参数
  #tv("alex")

  #login相当于tv = login(tv)当程序没有调用的时候执行也返回让用户调用,显然是不合理的。这样没有执行调用就需要验证显然是不合理的,要想办法让程序没有调用的时候不要指定调用。

  def login(func):
  #登录验证模块
    def inner(name):
    #设置让用户调用的时候执行,否则不执行,避免没有调用就执行。
      print("passed user verification......")
      func(name)
    return inner

  def home(name):
    print("Welcome [%s] to home page." %name)
  def tv(name):
    print("Welcome [%s] to TV page." %name)
  def movie(name):
    print("Welcome [%s] to movie page." %name)

  tv = login(tv)
  #把tv当作参数传递给login函数,然后返回tv参数
  #tv("alex")

  在上面程序中,我们在验证模块嵌套了一层函数,用于让用户在没有调用的情况下,执行程序不会执行验证模块,为什么可以呢?我们知道,执行函数需要函数名function()加上括号才能够执行,因此我们在这行循环的时候返回内存函数名,然后进行调用,这样就能够在用户验证的时候执行验证模块,而在用户没有调用的过程中,返回函数名,但是这样时候因为只有函数名,因而是不能够执行函数的。

  下面来看看用装饰器实现的情况:

  def login(func):
    #登录验证模块
    def inner(name):
      #设置让用户调用的时候执行,否则不执行,避免没有调用就执行。
      print("passed user verification......")
      func(name)
    return inner

  def home(name):
    print("Welcome [%s] to home page." %name)
  @login
  def tv(name):
    print("Welcome [%s] to TV page." %name)
  @login
    def movie(name):
  print("Welcome [%s] to movie page." %name)

  #tv = login(tv)
  #把tv当作参数传递给login函数,然后返回tv参数
  tv("alex")
  movie("tom")  

  上面代码中,我们使用了装饰器,让程序在运行的过程中首先使用了装饰器,装饰器相当于tv = login(tv)让第一次函数返回的值赋值给tv,这样在用户调用tv函数的时候,其实并没有执行tv函数的代码,而是执行内存函数的代码,就直接调用第二次验证模块,验证完成之后,我们指定用户打印模块。这样我们就避免了在用户还没有调用的时候就执行了验证模块。