Detaillierte Erklärung der Python-Dekoratoren von flach bis tief

Die Funktion des Dekorators ist in vielen Sprachen verfügbar und auch die Namen sind unterschiedlich. Tatsächlich verkörpert sie ein Designmuster, das das offene und geschlossene Prinzip betont. Es wird eher für spätere Funktionserweiterungen verwendet als für das Schreiben neuer. Code. Dekorateure können nicht nur Funktionen dekorieren, sondern auch andere Objekte wie Klassen. Normalerweise verwenden wir jedoch dekorierte Funktionen als Beispiel, um deren Verwendung vorzustellen. Um zu verstehen, wie Dekoratoren in Python funktionieren, müssen Sie Schritt für Schritt vorgehen. Dieser Artikel versucht so einfach und leicht verständlich wie möglich zu sein und beginnt mit den grundlegendsten Inhalten.

(Hinweis: Im Folgenden wird die Python3.5.1-Umgebung verwendet)

1. Funktionsbezogene Grundlagen von Python

Zunächst muss betont werden, dass Python sequentiell ausgeführt wird Von oben nach unten: Wenn Sie auf den Definitionscodeblock der Funktion stoßen, wird dieser nicht sofort ausgeführt. Erst wenn die Funktion aufgerufen wird, wird der interne Codeblock ausgeführt.

def foo():
print("foo函数被运行了！")
如果就这么样，foo里的语句是不会被执行的。
程序只是简单的将定义代码块读入内存中。

Schauen Sie sich noch einmal das Beispiel der sequentiellen Ausführung an:

def foo():
 print("我是上面的函数定义！")
def foo():
 print("我是下面的函数定义！")
foo()
运行结果：
我是下面的函数定义

Es ist ersichtlich, dass aufgrund der sequentiellen Ausführung das Foo unten das Foo oben überdeckt. Daher gibt es Anforderungen für die Platzierung von Code in Python und kann nicht willkürlich platziert werden. Der Funktionskörper muss vor der aufgerufenen Anweisung platziert werden.

Zweitens müssen wir zuerst ein paar Dinge herausfinden: Funktionsname, Funktionskörper, Rückgabewert, Speicheradresse der Funktion, Funktionsname plus Klammern, Funktionsname plus Klammern werden als Parameter behandelt, Funktionsname plus Klammern werden als Parameter, Rückgabefunktionsname, Rückgabefunktionsname plus Klammern behandelt. Für die folgenden Funktionen:

def foo():
print("让我们干点啥！")
return "ok"
foo() 　

Funktionsname: foo

Funktionskörper: Zeilen 1-3

Rückgabewert: String „ok“ Wenn nicht explizit. Wenn die Rückgabe erfolgt Wenn ein Objekt angegeben ist, wird standardmäßig Keines zurückgegeben. Zeigt auf den Speicherort, an dem der Funktionskörper im Speicher gespeichert ist.

Funktionsname plus Klammern: Zum Beispiel foo(), die Funktionsaufrufmethode. Solange diese Klammern sichtbar sind, findet das Programm den Funktionskörper aus dem Speicher basierend auf dem Funktionsnamen und führt ihn dann aus it

Sehen Sie sich noch einmal das folgende Beispiel an:

In Python ist alles ein Objekt und Funktionen sind keine Ausnahme. Daher können Sie den Funktionsnamen oder sogar den Funktionsnamen mit Klammern zum Aufrufen als Rückgabewert einer anderen Funktion verwenden. Im obigen Code sind „outer“ und „foo“ zwei Funktionen. „outer(foo)“ bedeutet, dass der Funktionsname der „foo“-Funktion als Parameter an die „outer“-Funktion übergeben wird und „outer(foo())“ bedeutet, dass der Rückgabewert nach der Ausführung von „foo“ behandelt wird Funktion als Die Parameter werden an die äußere Funktion übergeben und die äußere Funktion wird ausgeführt. Da die foo-Funktion keinen Rückgabewert angibt, übergibt sie tatsächlich einen None an die äußere Funktion. Achten Sie auf den Unterschied, ob es Klammern gibt oder nicht!

In ähnlicher Weise wird innerhalb der äußeren Funktion eine innere zurückgegeben, bei der es sich um eine innerhalb der äußeren Funktion definierte Funktion handelt. Beachten Sie, dass der Funktionskörper von inner zurückgegeben wird, da nach der inneren Funktion keine Klammern stehen Funktionskörper von inner Es ist nur der Name inner, eine einfache Referenz. Was ist also, wenn die äußere Funktion inner() zurückgibt? Sie sollten jetzt ganz klar sein, dass zuerst der Inhalt der inneren Funktion ausgeführt wird und dann None an die äußere Funktion zurückgegeben wird, und die äußere Funktion gibt None an das Objekt zurück, das sie aufgerufen hat.

def outer(func):
 def inner():
 print("我是内层函数！")
 return inner
def foo():
 print("我是原始函数！")
outer(foo)
outer(foo())

Bitte denken Sie daran, dass der Funktionsname, die Funktion plus Klammern als Parameter übergeben oder als Rückgabewert zurückgegeben werden können. Das Vorhandensein oder Fehlen von Klammern hat zwei völlig unterschiedliche Bedeutungen!

2. Verwendungsszenarien von Dekoratoren

Dekoratoren werden normalerweise verwendet, um dem ursprünglichen Funktionscode und der ursprünglichen Funktionalität zusätzliche Funktionen hinzuzufügen, ohne diese zu ändern. Führen Sie beispielsweise etwas aus, bevor die ursprüngliche Funktion ausgeführt wird, und führen Sie etwas nach der Ausführung aus.

Nehmen wir ein Beispiel, um die Einsatzszenarien von Dekorateuren und die Designmuster zu sehen, die sie verkörpern. (Es tut mir leid, dass ich kein besseres Szenario entwerfen kann, daher kann ich nur Wu Dashens Fall zitieren, um es abzuleiten)

Es gibt ein großes Unternehmen, und seine grundlegende Plattformabteilung ist für die Entwicklung verantwortlich Interne Anwendungen und APIs sind für verschiedene Unternehmen verantwortlich und rufen jeweils unterschiedliche Funktionen auf, die von der Basisplattformabteilung bereitgestellt werden, um ihr eigenes Geschäft abzuwickeln Das Unternehmen befindet sich in einem frühen Stadium des Unternehmertums, wenn die Basisplattformabteilung diese Funktionen entwickelt. Aus verschiedenen Gründen, wie z. B. Zeit, mangelnder Überlegung usw., wird für Funktionsaufrufe keine Sicherheitsauthentifizierung durchgeführt. Nun beschloss der Direktor der Plattformabteilung, diesen Fehler zu beheben, also:

Beim ersten Mal rief der Direktor einen Betriebs- und Wartungsingenieur an, und der Ingenieur lief auf und ab, um die Abteilungen nacheinander zu benachrichtigen Er forderte sie auf, dem Code Authentifizierungsfunktionen hinzuzufügen. Er wurde jedoch an diesem Tag entlassen.

　第二回：主管又叫来了一个运维工程师，工程师用shell写了个复杂的脚本，勉强实现了功能。但他很快就回去接着做运维了，不会开发的运维不是好运维....

　第三回：主管叫来了一个python自动化开发工程师，哥们是这么干的：只对基础平台的代码进行重构，让N个业务部门无需做任何修改。这哥们很快也被开了，连运维也没得做。　　

def f1():
 #加入认证程序代码
 print("业务部门1数据接口......")
def f2():
 # 加入认证程序代码
 print("业务部门2数据接口......")
def f3():
 # 加入认证程序代码
 print("业务部门3数据接口......")
def f100():
 #加入认证程序代码
 print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()

　第四回：主管又换了个 工程师，他是这么干的：定义个认证函数，原来其他的函数调用它，代码如下框。但是，主管依然不满意，不过这一次他解释了为什么。主管说：写代码要遵循开放封闭原则，虽然在这个原则主要是针对面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码内部不允许被修改，但外部可以被扩展，即：封闭：已实现的功能代码块；开放：对扩展开放。如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3......f100的内部进行代码修改。遗憾的是，工程师没有漂亮的女朋友，所以很快也被开除了。

def login():
 print("认证成功！")
def f1():
 login()
 print("业务部门1数据接口......")
def f2():
 login()
 print("业务部门2数据接口......")
def f3():
 login()
 print("业务部门3数据接口......")
def f100():
 login()
 print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()

第五回：已经没有时间让主管找别人来干这活了，他决定亲自上阵，并且打算在函数执行后再增加个日志功能。主管是这么想的：不会装饰器的主管不是好码农！要不为啥我能当主管，你只能被管呢？嘿嘿。他的代码如下：

#/usr/bin/env python
#coding:utf-8
def outer(func):
 def inner():
 print("认证成功！")
 result = func()
 print("日志添加成功")
 return result
 return inner
@outer
def f1():
 print("业务部门1数据接口......")
@outer
def f2():
 print("业务部门2数据接口......")
@outer
def f3():
 print("业务部门3数据接口......")
@outer
def f100():
 print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()

对于上述代码，也是仅需对基础平台的代码进行拓展，就可以实现在其他部门调用函数 f1 f2 f3 f100 之前都进行认证操作，在操作结束后保存日志，并且其他业务部门无需他们自己的代码做任何修改，调用方式也不用变。“主管”写完代码后，觉得独乐了不如众乐乐，打算显摆一下，于是写了篇博客将过程进行了详细的说明。

三、装饰器的内部原理、

　下面我们以f1函数为例进行说明：

def outer(func):
 def inner():
 print("认证成功！")
 result = func()
 print("日志添加成功")
 return result
 return inner
@outer
def f1():
 print("业务部门1数据接口......")

运用我们在第一部分介绍的知识来分析一下上面这段代码：

程序开始运行，从上往下编译，读到def outer(func):的时候，发现这是个“一等公民”->函数，于是把函数体加载到内存里，然后过。

读到@outer的时候，程序被@这个语法糖吸引住了，知道这是个装饰器，按规矩要立即执行的，于是程序开始运行@后面那个名字outer所定义的函数。（相信没有人会愚蠢的将@outer写到别的位置，它只能放在被装饰的函数的上方最近处，不要空行。）

程序返回到outer函数，开始执行装饰器的语法规则，这部分规则是定死的，是python的“法律”，不要问为什么。规则是：被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数执行它自己内部的代码后，会将它的返回值赋值给被装饰的函数。　

如下图所示：

这里面需要注意的是：

@outer和@outer()有区别，没有括号时，outer函数依然会被执行，这和传统的用括号才能调用函数不同，需要特别注意！那么有括号呢？那是装饰器的高级用法了，以后会介绍。

是f1这个函数名（而不是f1()这样被调用后）当做参数传递给装饰函数outer，也就是：func = f1，@outer等于outer(f1),实际上传递了f1的函数体，而不是执行f1后的返回值。

outer函数return的是inner这个函数名，而不是inner()这样被调用后的返回值。

如果你对第一部分函数的基础知识有清晰的了解，那么上面的内容你应该很容易理解。

　4. 程序开始执行outer函数内部的内容，一开始它又碰到了一个函数，很绕是吧？当然，你可以在 inner函数前后安排点别的代码，但它们不是重点，而且有点小麻烦，下面会解释。inner函数定义块被程序观察到后不会立刻执行，而是读入内存中（这是潜规则）。

　5. 再往下，碰到return inner，返回值是个函数名，并且这个函数名会被赋值给f1这个被装饰的函数，也就是f1 = inner。根据前面的知识，我们知道，此时f1函数被新的函数inner覆盖了（实际上是f1这个函数名更改成指向inner这个函数名指向的函数体内存地址，f1不再指向它原来的函数体的内存地址），再往后调用f1的时候将执行inner函数内的代码，而不是先前的函数体。那么先前的函数体去哪了？还记得我们将f1当做参数传递给func这个形参么？func这个变量保存了老的函数在内存中的地址，通过它就可以执行 老的函数体，你能在inner函数里看到result = func（）这句代码，它就是这么干的！

　6.接下来，还没有结束。当业务部门，依然通过f1()的方式调用f1函数时，执行的就不再是老的f1函数的代码，而是inner函数的代码。在本例中，它首先会打印个“认证成功”的提示，很显然你可以换成任意的代码，这只是个示例；然后，它会执行func函数并将返回值赋值个变量result，这个func函数就是老的f1函数；接着，它又打印了“日志保存”的提示，这也只是个示例，可以换成任何你想要的；最后返回result这个变量。我们在业务部门的代码上可以用 r = f1()的方式接受result的值。

　7.以上流程走完后，你应该看出来了，在没有对业务部门的代码和接口调用方式做任何修改的同时，也没有对基础平台部原有的代码做内部修改，仅仅是添加了一个装饰函数，就实现了我们的需求，在函数调用前先认证，调用后写入日志。这就是装饰器的最大作用。

　问题：那么为什么我们要搞一个outer函数一个inner函数这么复杂呢？一层函数不行吗？

　答：请注意，@outer这句代码在程序执行到这里的时候就会自动执行outer函数内部的代码，如果不封装一下，在业务部门还未进行调用的时候，就执行了些什么，这和初衷有点不符。当然，如果你对这个有需求也不是不行。请看下面的例子，它只有一层函数。

def outer(func):
 print("认证成功！")
 result = func()
 print("日志添加成功")
 return result
@outer
def f1():
 print("业务部门1数据接口......")
# 业务部门并没有开始执行f1函数
执行结果：
认证成功！
业务部门1数据接口......
日志添加成功

看到没？我只是定义好了函数，业务部门还没有调用f1函数呢，程序就把工作全做了。这就是封装一层函数的原因。

四、装饰器的参数传递

细心的朋友可能已经发现了，上面的例子中，f1函数没有参数，在实际情况中肯定会需要参数的，那参数怎么传递的呢？

　一个参数的情况：

def outer(func):
 def inner(username):
 print("认证成功！")
 result = func(username)
 print("日志添加成功")
 return result
 return inner
@outer
def f1(name):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack")

在inner函数的定义部分也加上一个参数，调用func函数的时候传递这个参数，很好理解吧？可问题又来了，那么另外一个部门调用的f2有2个参数呢？f3有3个参数呢？你怎么传递？

很简单，我们有*args和**kwargs嘛！号称“万能参数”！简单修改一下上面的代码：

def outer(func):
 def inner(*args,**kwargs):
 print("认证成功！")
 result = func(*args,**kwargs)
 print("日志添加成功")
 return result
 return inner
@outer
def f1(name,age):
 print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)

五、更进一步的思考

　一个函数可以被多个函数装饰吗？可以的！看下面的例子！　　

def outer1(func):
 def inner(*args,**kwargs):
 print("认证成功！")
 result = func(*args,**kwargs)
 print("日志添加成功")
 return result
 return inner
def outer2(func):
 def inner(*args,**kwargs):
 print("一条欢迎信息。。。")
 result = func(*args,**kwargs)
 print("一条欢送信息。。。")
 return result
 return inner
 @outer1
@outer2
def f1(name,age):
 print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
执行结果：
认证成功！
一条欢迎信息。。。
jack 正在连接业务部门1数据接口......
一条欢送信息。。。
日志添加成功

更进一步的，装饰器自己可以有参数吗？可以的！看下面的例子：

# 认证函数
def auth(request,kargs):
 print("认证成功！")
# 日志函数
def log(request,kargs):
 print("日志添加成功")
# 装饰器函数。接收两个参数，这两个参数应该是某个函数的名字。
def Filter(auth_func,log_func):
 # 第一层封装，f1函数实际上被传递给了main_fuc这个参数
 def outer(main_func):
 # 第二层封装，auth和log函数的参数值被传递到了这里
 def wrapper(request,kargs):
 # 下面代码的判断逻辑不重要，重要的是参数的引用和返回值
 before_result = auth(request,kargs)
 if(before_result != None):
 return before_result;
 main_result = main_func(request,kargs)
 if(main_result != None):
 return main_result;
 after_result = log(request,kargs)
 if(after_result != None):
 return after_result;
 return wrapper
 return outer
# 注意了，这里的装饰器函数有参数哦，它的意思是先执行filter函数
# 然后将filter函数的返回值作为装饰器函数的名字返回到这里，所以，
# 其实这里，Filter(auth,log) = outer , @Filter(auth,log) = @outer
@Filter(auth,log)
def f1(name,age):
 print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
运行结果：
认证成功！
jack 正在连接业务部门1数据接口......
日志添加成功

又绕晕了？其实你可以这么理解，先执行Filter函数，获得它的返回值outer，再执行@outer装饰器语法。

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持PHP中文网！

更多Detaillierte Erklärung der Python-Dekoratoren von flach bis tief相关文章请关注PHP中文网！