Verstehen von Schließungen und Dekoratoren in Python

Abschlüsse werden in Python ausdrücklich wie folgt definiert (interpretiert): Wenn in einer inneren Funktion auf eine Variable im äußeren Bereich (aber nicht im globalen Bereich) verwiesen wird, gilt die innere Funktion als Abschluss.

Die folgenden Anweisungen gelten hauptsächlich für Python2.7, es können Unterschiede in anderen Versionen auftreten.

Vielleicht ist es nicht klar, wenn man sich die Definition direkt anschaut. Schauen wir uns zunächst an, was interne Funktionen sind:

def wai_hanshu(canshu_1):

  def nei_hanshu(canshu_2): # 我在函数内部有定义了一个函数
    return canshu_1*canshu_2

  return nei_hanshu  # 我将内部函数返回出去

a = wai_hanshu(123)   # 此时 canshu_1 = 123
print a
print a(321)  # canshu_2 = 321

Ich habe eine Funktion in der Funktion verschachtelt. Wenn ich eine Variable an die äußere Funktion übergebe und sie a zuweise, stellen wir fest, dass a zu einem Funktionsobjekt wird, und wenn ich Parameter an diese übergebe Wenn Sie das Funktionsobjekt erneut aufrufen, wird der Rückgabewert der internen Funktion erhalten. Wir wissen, dass wir gemäß dem Geltungsbereichsprinzip nicht auf den lokalen Bereich im globalen Bereich zugreifen können. Allerdings erfolgt der Zugriff auf die internen Funktionen hier über eine knifflige Methode. .

Schauen wir uns weiterhin ein Beispiel an:

def wai_hanshu():
  a = []
  def nei_hanshu(canshu):
    a.append(canshu)
    return a

  return nei_hanshu

a = wai_hanshu()
print a(123)
print a(321)

Es ist zu erkennen, dass die Funktion befindet sich in der externen Funktionsliste a in hat sich geändert. Um herauszufinden, warum, müssen Sie zunächst wissen, was ein Python-Namespace ist, und der Namespace ist der Grund für die Bereichsleistung. Lassen Sie es mich hier kurz erläutern.

Der Hauptgrund für die Einführung von Namespaces besteht darin, Variablenkonflikte zu vermeiden, da es in Python viele Module gibt und die Module Funktionen, Klassen usw. enthalten und alle Variablen verwenden. Aber es wäre zu mühsam, wenn man darauf achten müsste, nicht jedes Mal mit anderen Variablennamen in Konflikt zu geraten. Entwickler sollten sich auf ihre eigenen Probleme konzentrieren, anstatt darüber nachzudenken, welche Variablen in von anderen geschriebenen Programmen verwendet werden. Deshalb hat Python Namespaces eingeführt. Der Namespace ist in Modulebene unterteilt, und das Modul ist in globalen Bereich und lokalen Bereich unterteilt. Wenn durch ein Diagramm dargestellt:

Die Namespaces unterscheiden sich zwischen den Modulen und Dort Es gibt auch globale Bereiche und lokale Bereiche können ebenfalls verschachtelt werden, um sicherzustellen, dass Variablennamen nicht in Konflikt geraten. Den Namen des Namespace können Sie übrigens über das Attribut __name__ erhalten:

Der Namespace der Hauptdatei heißt „__main__“ und der Namespace des Moduls ist der Modulname. Der Bereich

wurde geboren, weil Python bei der Suche nach einer Variablen zuerst im aktuellen Namespace danach sucht. Wenn sie im aktuellen Namespace nicht gefunden wird, sucht es in der oberen Ebene danach Analog dazu wird eine Ausnahme von „Variable nicht gefunden“ ausgelöst, wenn sie am Ende nicht gefunden wird.

Wir haben schon immer gesagt: Der globale Bereich kann nicht auf den lokalen Bereich zugreifen, aber der lokale Bereich kann aus diesem Grund auf den globalen Bereich zugreifen. Und wenn ich im lokalen Bereich eine Variable mit demselben Namen wie außerhalb erstelle und Python nach dieser Variablen sucht, sucht es zunächst im aktuellen Bereich danach. Wenn es gefunden wird, wird nicht weiter danach gesucht eine Ebene höher.

In frühen Python-Versionen konnten lokale Bereiche nicht auf andere lokale Bereiche zugreifen, sondern nur auf die globalen. In aktuellen Versionen werden sie jedoch eine Ebene höher der Reihe nach durchsucht, daher werde ich es hier erwähnen.

Aufgrund dieser Funktion können wir auf die Variablen in der externen Funktion in der internen Funktion zugreifen, was auch der sogenannte Abschluss ist.

Hinweis: Hier muss zwischen Objekten unterschieden werden, zum Beispiel:

def wai_hanshu():
  a = []
  def nei_hanshu(canshu):
    a.append(canshu)
    return a

  return nei_hanshu

a = wai_hanshu()  # 我创建了一个对象
b = wai_hanshu()  # 我又创建了一个对象
print a
print b
print a(123)
print b(321)

Obwohl wir hier alle Betriebsvariablen in wai_hanshu sind, sind a und b vollständig zwei Objekte, und die Speicherräume, in denen sie sich befinden, sind ebenfalls unterschiedlich, sodass die darin enthaltenen Daten ebenfalls unabhängig sind. Achten Sie darauf, die Dinge nicht durcheinander zu bringen.

Dekorateur

Tatsächlich führt der Dekorateur basierend auf dem Abschluss noch ein paar Schritte aus:

def zsq(func): # 装饰函数
  def nei():
    print '我在传入的函数执行之前做一些操作'
    func() # 执行函数
    print '我在目标函数执行后再做一些事情'
  return nei

def login():  # 被装饰函数
  print '我进行了登录功能'

login = zsq(login)  # 我将被装饰的函数传入装饰函数中，并覆盖了原函数的入口

login()   # 此时执行的就是被装饰后的函数了

在看这段代码的时候，要知道几件事：

1.函数的参数传递的其实是引用，而不是值。

2.函数名也是一个变量，所以可以重新赋值。

3.赋值操作的时候，先执行等号右边的。

只有明白了上面这些事之后，再结合一下代码，应该就能明白什么是装饰器了。所谓装饰器就是在闭包的基础上传递了一个函数，然后覆盖原来函数的执行入口，以后调用这个函数的时候，就可以额外实现一些功能了。装饰器的存在主要是为了不修改原函数的代码，也不修改其他调用这个函数的代码，就能实现功能的拓展。

而python觉得让你每次都进行重命名操作实在太不方便，于是就给出了一个便利的写法：

def zsq(func):
  def nei():
    print '我在传入的函数执行之前做一些操作'
    func() # 执行函数
    print '我在目标函数执行后再做一些事情'
  return nei

@zsq  # 自动将其下面的函数作为参数传到装饰函数中去
def login():
  print '我进行了登录功能'


login()

这些小便利也叫做python的语法糖，你可能在很多地方见过这个说法。

带参数的装饰器：

def zsq(a):
  print '我是装饰器的参数', a
  def nei(func):
    print '我在传入的函数执行之前做一些操作'
    func() # 执行函数
    print '我在目标函数执行后再做一些事情'
  return nei


@zsq('123')
def login():
  print '我进行了登录功能'

相当于： login = zsq(123)(login) ，所以在这里没有调用就执行了。

装饰器的嵌套：

这里就不完整写个例子了：

@deco1(deco_arg) 
@deco2 
def func(): 
  pass

相当于： func = deco1(deco_arg)(deco2(func)) 

也就是从上到下的嵌套了。

关于闭包和装饰器就先讲到这里，以后有需要再补充。

以上这篇深入Verstehen von Schließungen und Dekoratoren in Python就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。

更多Verstehen von Schließungen und Dekoratoren in Python相关文章请关注PHP中文网！