装饰器

为了增加功能而对函数或者类进行功能扩充的一种语法。

  • 定义增加功能的函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#定义增加功能的函数
def decor(func):
  #增加功能1
  print('抱抱')
  #调用基本函数
  func()#相当于调用love
  #增加功能2
  print('举高高')

#基本函数
def love():
  print('亲亲')

love = decor(love)#将基本函数作为参数传入装饰函数中

#调用函数
#love()
print(love)
  • 基本的装饰器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#装饰器函数
def decor(func):
  #声明一个内部函数
  def inner():
    # 增加功能1
    print('抱抱')
    # 调用基本功能
    func()
    # 增加功能2
    print('举高高')

  #必须返回函数
  return inner #未来的love函数

#基本函数
def love():
  print('亲亲')
love = decor(love)#装饰操作
#print(love)
#调用函数
love()
  • 装饰器函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def decor(func):
  #定义内部函数 就是未来的love函数
  def inner():
    #增加功能1
    print('抱抱')
    #调用基本函数
    func()
    #增加功能2
    print('举高高')

  #返回内部函数
  return inner

#定义基本函数
@decor #装饰操作   等价于  love = decor(love)
def love():
  print('亲亲')
#调用函数
love()
  • 为基本函数添加返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def decor(func):
  #定义一个内部函数
  def inner():
    #增加的功能
    print('抱抱')
    #基本功能
    var = func()#相当于调用了love
    #增加的功能
    print('举高高')
    #返回一个值 是原有基本函数的返回值
    return var
  #返回内部函数
  return inner

#定义基本函数
@decor # love = decor(love)
def love():
    print('亲亲')
    return '❤'

#调用函数
result = love()
print(result)
  • 为基本函数添加参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def decor(func):
  #定义内部函数
  def inner(w1,w2):
    #增加功能1
    print('抱抱')
    #调用基本功能
    func(w1,w2) #相当调用love
    #增加功能2
    print('举高高')
  #返回内部函数inner  是未来的love函数
  return inner

#定义基本函数
@decor  # love = decor(love)
def love(who1,who2):
    print('{}亲亲{}'.format(who1,who2))
#调用函数
love('妈妈','女儿')
  • 加上收集参数(收集参数，关键字收集参数)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def decor(func):
  #定义内部函数
  def inner(*p,**w):#装饰之后的love函数
      #增加功能
      print('抱抱')
      #基本函数
      func(*p,**w)
      #增加功能2
      print('举高高')
  #返回内部函数
  return inner

#定义基本函数
@decor  # love = decor(love)
def love(*parent,**child):
    print(parent,'亲亲',child)
#调用基本函数
love('爸爸','妈妈',son = '儿子',girl = '女儿')
  • 为装饰器添加参数
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
def outer(arg): #调用outer返回装饰器
  #定义装饰器  #---------------------start----------------------
  def decor(func):
    #定义内部函数
    def inner():
      #判断正在装饰的函数
      if arg == 'xiao':
        # 增加功能
        print('我给你将一个笑话')
        # 调用基本函数
        func()
        # 增加功能
        print('肚子疼了吧')
      elif arg == 'ku':
        #增加功能1
        print('告诉你一个不行的消息')
        # 调用基本函数
        func()
        #增加功能2
        print('没事，节哀顺变~')
    #返回内部函数
    return inner
  #-----------------end---------------------------
  #返回装饰器
  return decor

#基本函数1
@outer('xiao')#@outer('xiao') ->@decor     #@函数
def smile():
    print('哈哈哈哈哈~')

#基本函数2
@outer('ku')#@outer('ku')  ->@decor #@函数
def cry():
  print('呜呜呜呜~')

#调用smile
#smile()
#调用cry
#cry()
  • 将类作为参数传入装饰器中使用
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
class Parent:
  #成员方法
  #抱抱
  def baobao():
      print('抱抱')
  #举高高
  def jugaogao():
      print('举高高')

#装饰器外层
def outer(cls):
  #装饰器
  def decor(func):
    #定义内部函数
    def inner():
      #增加功能
      cls.baobao()
      #基本函数
      func()
      #增加功能2
      cls.jugaogao()
    #返回内部函数
    return inner
  #返回装饰器
  return decor

#基本函数
#@函数(类)  ->@装饰器
@outer(Parent)
def love():
    print('亲亲')
#调用函数
love()