Étude approfondie de python decorators_python

Cet article fournit principalement une étude approfondie des informations relatives aux décorateurs Python. Qu'est-ce qu'un décorateur ? Les principes suivis par les décorateurs ont une certaine valeur de référence. Les amis intéressés peuvent se référer à

Qu'est-ce qu'un décorateur

dans la mise à niveau de notre produit logiciel. Parfois, nous devons souvent en ajouter de nouveaux. fonctions à chaque fonction. Dans nos produits logiciels, la même fonction peut être appelée des centaines de fois. Cette situation est très courante. Si nous la modifions une par une, nos programmeurs le feront. Pourquoi ne raccrochez-vous pas (quelqu'un a dit, vous). sont stupides, modifiez simplement la définition de la fonction ! Camarade de classe, réveillez-vous, et si la fonction nouvellement ajoutée modifiait les paramètres ou renvoyait une valeur ?). A cette époque, il est temps pour notre décorateur de montrer sa magie. Les décorateurs peuvent réaliser la fonction d'ajouter de nouvelles fonctions à la fonction sans changer la forme d'appel de la fonction d'origine (c'est-à-dire le traitement transparent de la fonction). Comment le mettre en œuvre, ainsi que le principe de mise en œuvre, seront expliqués en détail ci-dessous.

Principes suivis par les décorateurs

Les décorateurs, comme leur nom l'indique, jouent le rôle de décoration Puisqu'il s'agit de décoration, l'objet décoré est quoi qu'il soit. be Il n’y a pas le moindre changement. Ici, lorsque nous écrivons aux décorateurs, nous devons saisir la loi d'airain selon laquelle le code source de la fonction modifiée ne peut pas être modifié. Comment suivre cette loi d'airain, nous devons encore faire quelques préparatifs. Nous devons d'abord comprendre trois concepts, comme suit :

Le nom de la fonction est "variable"

En Python, le nom de la fonction est en fait comme un pointeur de fonction en langage C, qui représente notre adresse de fonction. Ce n'est que lorsque l'interpréteur obtiendra cette adresse qu'il exécutera ce morceau de code. Par conséquent, en substance, le nom de la fonction n'est pas différent des différentes variables, sauf que le nom de la fonction et la mémoire pointée par la variable ordinaire sont utilisés de différentes manières. Ceux-ci sont déterminés par le mécanisme de l'interpréteur sous-jacent. sont tous deux transparents, on peut donc penser qu'il n'y a pas de différence entre les deux.

Fonctions d'ordre supérieur

Ce qu'est une fonction d'ordre supérieur est en fait très simple, il suffit de saisir deux principes :

• Les paramètres formels ont des noms de fonction

• Les valeurs de retour ont des noms de fonction
  

Tant qu'un Si l’un ou l’autre de ces deux principes est respecté, on peut l’appeler une fonction d’ordre supérieur. Avec le recul, le nom de la fonction que nous avons mentionné ci-dessus apparaît ici. Si vous y réfléchissez bien, ne le traitons-nous pas ici comme un véritable paramètre ?

Fonction imbriquéeNuméro

Ce qu'est une fonction imbriquée est en fait très simple, il suffit saisir un principe :

• Définir une autre fonction dans le corps de fonction d'une fonction
  

Ce qui doit être souligné ici Oui, quand une fonction est définie, le corps de la fonction ne sera pas exécuté, tout comme lorsqu'une variable est définie, le contenu de la variable ne sera pas lu. Ceci est crucial et très utile pour nous permettre de comprendre le principe de mise en œuvre du décorateur.

Comment écrire un décorateur

Avec la préfiguration ci-dessus, expliquons maintenant comment écrire un décorateur, afin que ce soit beaucoup plus facile à comprendre.

L'essence du décorateur

En fait, un décorateur est essentiellement une fonction, qui a également un nom de fonction, des paramètres et une valeur de retour. Mais en python, on utilise "@auth" pour le représenter.

@auth    # 其等价于：func = auth(func)
def func():
  print("func called")

Cet exemple montre comment modifier le format de la fonction func en python. Bien sûr, nous n'avons pas encore implémenté notre fonction décorateur. Ce à quoi nous devons prêter attention, c'est le contenu écrit dans les commentaires. Nous pouvons voir que :

• La fonction décorateur est en fait une fonction d'ordre supérieur (à la fois les paramètres et les valeurs de retour). sont des noms de fonctions).

• "auth(func)" appelle notre fonction décorateur, c'est-à-dire que le corps de la fonction décorateur sera exécuté.
  

Idée de conception

Puisque le décorateur est une fonction, il a la relation d'équivalence introduite ci-dessus, alors nous pouvons concevoir notre décorateur comme ceci :

• Définir une nouvelle fonction dans le corps de la fonction de notre décorateur, et appeler la fonction modifiée dans cette fonction nouvellement définie. Les fonctions, quant à elles, ajoutent de nouvelles fonctionnalités dans le cadre de la fonction modifiée. Enfin, utilisez la valeur de retour de la fonction décorateur pour renvoyer le nom de notre fonction nouvellement définie.
  

• De là, nous pouvons savoir que la valeur de retour func dans "func = auth(func)" représente le nom de la fonction nouvellement définie dans le décorateur.

J'ai déjà fait beaucoup de préparation, histoire de dévoiler ici le mécanisme de mise en œuvre du décorateur. En fait, ce n'est rien, c'est très simple :

.

• 装饰器机制改变了被修饰函数的函数名表示的地址数据。说白了就是，被修饰前，函数名代表的是A内存块；被修饰后，函数名代表的是B内存块；只不过，在执行B内存块时，会调用A内存块罢了。B内存块中的代码就是我们新加的功能。而这种机制的实现，使用了“高阶函数”和“嵌套函数”的机制。
  

• 最终的效果就是，但在调用被修饰过的函数时，其实调用的不是原来的内存块，而是修饰器新申请的内存块。

第一步：设计装饰器函数

装饰器函数定义跟普通函数定义没什么区别，关键是函数体怎么写的问题。这里，为了便于理解，先用无参数的装饰器函数说明。

#装饰器函数定义格式
def deco(func):
  '''函数体...'''
return func

这里说的无参数，指的是没有除了“func”之外的参数
难点是函数体的编写，下面的示例先告诉你为什么要有第二步：

#使用语法糖@来装饰函数，相当于“myfunc = deco(myfunc)”
def deco(func):
  print("before myfunc() called.")
  func()
  print("after myfunc() called.")
  return func
 
@deco
def myfunc():
  print("myfunc() called.")
 
myfunc()
myfunc()
 
#output：
before myfunc() called.
myfunc() called.
after myfunc() called.
myfunc() called.
myfunc() called.

由输出结果可以看出，我们的装饰器并没有生效。别跟我说装饰器只生效了一次，那是大家忽略了“@deco”的等效机制。解释到“@deco”时，会解释成“myfunc = deco(myfunc)”。注意了，前面我提到了，这里其实在调用deco函数的，因此，deco的函数体会被执行。所以output的前三行并不是调用myfunc函数时产生的效果，那有怎能说装饰器生效了一次呢？第二步就是解决装饰器没生效的问题的。

第二步：包装被修饰函数

#基本格式
def deco(func):
  def _deco()
    #新增功能
    #...
    #...
    func() #别修饰函数调用
  return_deco

 下面给出个示例：

#使用内嵌包装函数来确保每次新函数都被调用，
#内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象
 
def deco(func):
  def _deco():
    print("before myfunc() called.")
    func()
    print("after myfunc() called.")
    # 不需要返回func，实际上应返回原函数的返回值
  return _deco
 
@deco
def myfunc():
  print("myfunc() called.")
  return 'ok'
 
myfunc()
 
#output:
before myfunc() called.
myfunc() called.
after myfunc() called.

  第三步：被修饰函数参数和返回值透明化处理

当完成了第二步时，其实装饰器已经完成了主要部分，下面就是对被修饰函数的参数和返回值的处理。这样才能真正实现装饰器的铁律。话不多说，直接上代码：

#基本格式
def deco(func):
  def _deco(*args, **kwargs) #参数透明化
    #新增功能
    #...
    #...
    res = func(*args, **kwargs) #别修饰函数调用
    return res #返回值透明化
  return_deco

通过上面的分析知：

参数透明化：当我们在调用被装饰后的函数时，其实调用的时这里的_deco函数。那么，我们就给_deco函数加上可变参数，并把得到的可变参数传递给func函数不就可以了。
返回值透明化：和参数透明化同理，给_deco函数定义返回值，并返回func的返回值就可以了。

透明化处理就是这么简单！至此，我们的装饰器编写完成。给个示例吧：

#对带参数的函数进行装饰，
#内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象
 
def deco(func):
  def _deco(*agrs, **kwagrs):
    print("before myfunc() called.")
    ret = func(*agrs, **kwagrs)
    print(" after myfunc() called. result: %s" % ret)
    return ret
  return _deco
 
@deco
def myfunc(a, b):
  print(" myfunc(%s,%s) called." % (a, b))
  return a + b
 
print("sum=",myfunc(1, 2))
print("sum=",myfunc(3, 4))
 
#output:
before myfunc() called.
 myfunc(1,2) called.
 after myfunc() called. result: 3
sum= 3
before myfunc() called.
 myfunc(3,4) called.
 after myfunc() called. result: 7
sum= 7

装饰器进阶

带参数装饰器

装饰器即然也是函数，那么我们也可以给其传递参数。我这里说的是：“@auth(auth_type = 'type1')”这中形式哟。先上个代码吧：

#基本格式
def deco(deco_type)
  def _deco(func):
    def __deco(*args, **kwargs) #参数透明化
      #新增功能
      #...
      #...
      print("deco_type:",deco_type) #使用装饰器参数
      res = func(*args, **kwargs) #别修饰函数调用
      return res #返回值透明化
    return __deco
  return_deco

 说白了，就是在原来的装饰器的基础上再在最外层套一个deco函数，并用其来接收装饰器参数。由于是在最外层套了一个函数，那么这个函数的形参的作用范围就是函数体内部，所以里面的函数定义中随便用啦，就这么任性。
那怎么理解解释器的解析过程呢？在这里，只要我们明白一点就好，那就是： “@auth(auth_type = 'type1')”等价于“func = auth(auth_type = 'type1')(func)” 。解释器会先翻译“auth(auth_type = 'type1')”，再将其返回值(假设给了_func这个不存在的函数名)当作函数指针，这里的_func函数名代表的是_deco，然后再去执行“func = _func(func)”，而这个func函数名代表的其实就是__deco。

至此，就达到了通过装饰器来传参的目的。给个示例吧：

#示例7: 在示例4的基础上，让装饰器带参数，
#和上一示例相比在外层多了一层包装。
#装饰函数名实际上应更有意义些
 
def deco(deco_type):
  def _deco(func):
    def __deco(*args, **kwagrs):
      print("before %s called [%s]." % (func.__name__, deco_type))
      func(*args, **kwagrs)
      print(" after %s called [%s]." % (func.__name__, deco_type))
    return __deco
  return _deco
 
@deco("mymodule")
def myfunc():
  print(" myfunc() called.")
 
@deco("module2")
def myfunc2():
  print(" myfunc2() called.")
 
myfunc()
myfunc2()
 
#output:
before myfunc called [mymodule].
 myfunc() called.
 after myfunc called [mymodule].
before myfunc2 called [module2].
 myfunc2() called.
 after myfunc2 called [module2].

多重装饰器修饰函数

如果说，我上面说的内容都理解了，那么这个东东，就太简单不过了。不就是把我们的是装饰器当中被修饰的函数，对它进行装饰吗？但我在这里还想说的是，我们换个角度看问题。我们的关注点放在原来的被修饰的函数上，就会发现，NB呀，我可以给它添加若干个功能撒。给个示例吧：

def deco(deco_type):
  def _deco(func):
    def __deco(*args, **kwagrs):
      print("before %s called [%s]." % (func.__name__, deco_type))
      func(*args, **kwagrs)
      print(" after %s called [%s]." % (func.__name__, deco_type))
    return __deco
  return _deco
 
@deco("module1")
@deco("mymodule")
def myfunc():
  print(" myfunc() called.")
 
@deco("module2")
def myfunc2():
  print(" myfunc2() called.")
 
myfunc()
 
#output：
before __deco called [module1].
before myfunc called [mymodule].
 myfunc() called.
 after myfunc called [mymodule].
 after __deco called [module1].

 注意结果哟，@deco("module1"),来修饰的deco("mymdule")的，和我们想的是一样的，完美！

相关推荐：

深度理解Python装饰器的概念和含义

Une explication simple des décorateurs python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!