Exemple d'analyse du processus d'exécution du décorateur Python

Cet article présente principalement le processus d'exécution du décorateur Python et analyse le principe, le processus d'exécution et les précautions de fonctionnement associées du décorateur Python sous forme d'exemples. Les amis dans le besoin peuvent se référer à

L'exemple d'analyse de. cet article Le processus d'exécution du décorateur Python. Je le partage avec vous pour votre référence. Les détails sont les suivants :

J'ai vu une phrase aujourd'hui : Les décorateurs utilisent en fait des fermetures. Si vous y réfléchissez bien, c'est effectivement le cas. aux fermetures encore aujourd'hui, nous avons essentiellement compris le processus d'exécution de la fermeture. En fait, il peut être facilement découvert après avoir ajouté quelques phrases. Il est préférable de résumer les idées pour les lecteurs afin de faciliter leur compréhension. Parlons-en à travers le code.

Le premier, le décorateur lui-même ne passe pas les paramètres, le processus est relativement simple

#!/usr/bin/python
#coding: utf-8
# 装饰器其实就是对闭包的使用
def dec(fun):
  print("call dec")
  def in_dec():
    print("call in_dec")
    fun()
  # 必须加上返回语句，不然的话会默认返回None
  return in_dec
@dec
def fun():
  print("call fun")
# 注意上面的返回语句加上还有不加上的时候这一句执行的区别
print(type(fun))
fun()
'''
通过观察输出结果可以知道函数执行的过程
call dec
<type &#39;function&#39;>
call in_dec
call fun
观察这几组数据以后，其实很容易发现，先执行装饰器，执行过装饰器以后，代码继续执行最后的print和fun()语句，
但是此时的fun函数其实是指向in_dec的，并不是@下面的fun函数，所以接下来执行的是in_dec，在in_dec中有一个fun()语句，
遇到这个以后才是执行@后面的fun()函数的。
&#39;&#39;&#39;

Le second, le décorateur lui-même passe les paramètres , je pense personnellement que c'est relativement compliqué. Il est préférable de résumer ce processus par vous-même. Si vous avez des questions, discutons-en ensemble

#!/usr/bin/python
#coding: utf-8
import time, functools
def performance(unit):
  print("call performance")
  def log_decrator(f):
    print("call log_decrator")
    @functools.wraps(f)
    def wrapper(*arg, **kw):
      print("call wrapper")
      t1 = time.time()
      t = f(*arg, **kw)
      t2 = time.time()
      tt = (t2 - t1) * 1000 if unit == "ms" else (t2 - t1)
      print 'call %s() in %f %s' % (f.__name__, tt, unit)
      return t
    return wrapper
  return log_decrator
@performance("ms")
def factorial(n):
  print("call factorial")
  return reduce(lambda x, y: x * y, range(1, 1 + n))
print(type(factorial))
#print(factorial.__name__)
print(factorial(10))
'''接下来的是输出结果，通过结果其实很容易发现执行的过程
call performance
call log_decrator 通过观察前两组的输出结果可以知道，先执行装饰器
<type &#39;function&#39;>
call wrapper
call factorial
call factorial() in 0.000000 ms
3628800
&#39;&#39;&#39;

Recommandations associées :

Analyse des principes et utilisation 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!