Beispielanalyse des Ausführungsprozesses des Python-Dekorators

Dieser Artikel stellt hauptsächlich den Ausführungsprozess des Python-Dekorators vor und analysiert das Prinzip, den Ausführungsprozess und die damit verbundenen Betriebsvorkehrungen des Python-Dekorators in Form von Beispielen. Freunde in Not können sich auf die Beispielanalyse von beziehen Dieser Artikel Der Ausführungsprozess des Python-Dekorators. Ich teile es Ihnen als Referenz mit:

Ich habe heute einen Satz gesehen: Wenn Sie sorgfältig darüber nachdenken, ist dies tatsächlich der Fall Heute haben wir im Grunde wieder den Ablauf der Schließung herausgefunden. Tatsächlich ist es nach dem Hinzufügen einiger Sätze leicht zu erkennen, dass die Ideen den Lesern am besten selbst zusammengefasst werden, um das Verständnis zu erleichtern. Lassen Sie uns durch Code darüber sprechen.

Beim ersten Fall übergibt der Dekorateur selbst keine Parameter. Der Vorgang ist relativ einfach.

#!/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;

Beim zweiten Fall übergibt der Dekorateur selbst Parameter. Persönlich Ich denke, es ist relativ kompliziert, diesen Prozess selbst zusammenzufassen. Wenn Sie Fragen haben, besprechen Sie diese gemeinsam

#!/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;

Verwandte Empfehlungen:

Analyse von die Prinzipien und Verwendung von Python-Dekoratoren

Das obige ist der detaillierte Inhalt vonBeispielanalyse des Ausführungsprozesses des Python-Dekorators. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!