Sprechen Sie kurz über Schließungen in Python

Abschlüsse in Python

Jemand hat vor ein paar Tagen eine Nachricht hinterlassen und ist sich über die Verwendung von 闭包 und re.sub nicht ganz im Klaren. Ich suchte auf Script Home und stellte fest, dass ich noch nie etwas über Schließungen geschrieben hatte, also beschloss ich, den Inhalt von Python zusammenzufassen und zu verbessern.

1. Das Konzept der Schließung

Zuerst müssen wir mit dem Grundkonzept beginnen. Was ist Schließung? Werfen wir einen Blick auf die Erklärung im Wiki:

Code kopieren Der Code lautet wie folgt:

Abschluss ist in der Informatik die Abkürzung für lexikalischen Abschluss, eine Funktion, die frei referenziert Variablen. Die referenzierte freie Variable verbleibt bei der Funktion, auch nachdem sie die Umgebung, in der sie erstellt wurde, verlassen hat. Daher kann man auch anders sagen, dass ein Abschluss eine Entität ist, die aus einer Funktion und der zugehörigen Referenzumgebung besteht. Abschlüsse können zur Laufzeit mehrere Instanzen haben, und unterschiedliche Referenzumgebungen und dieselbe Funktionskombination können unterschiedliche Instanzen erzeugen.
....

Zwei Schlüsselpunkte wurden oben erwähnt: freie Variablen und Funktionen. Diese beiden Schlüssel werden später besprochen. Ich muss noch näher auf die Bedeutung von „Abschluss“ eingehen. Wie aus dem Text hervorgeht, handelt es sich bei diesem Paket um eine Funktion Innerhalb des Pakets gibt es Freiheitsvariablen, freie Variablen können mit dem Paket herumwandern. Natürlich muss es eine Voraussetzung dafür geben, dass dieses Paket erstellt wird.

Lassen Sie mich es durch die Python-Sprache vorstellen. Ein Abschluss bedeutet, dass Sie eine Funktion A aufrufen und diese Funktion A eine Funktion B an Sie zurückgibt. Diese zurückgegebene Funktion B wird als Abschluss bezeichnet. Die Parameter, die Sie beim Aufruf von Funktion A übergeben, sind freie Variablen.

Zum Beispiel:

def func(name):
 def inner_func(age):
  print 'name:', name, 'age:', age
 return inner_func

bb = func('the5fire')
bb(26) # >>> name: the5fire age: 26

Wenn func hier aufgerufen wird, wird ein Abschluss – inner_func – generiert, und der Abschluss enthält den Namen der freien Variablen. Dies bedeutet also auch, dass der Variablenname vorhanden bleibt, wenn der Lebenszyklus der Funktion func endet, da auf ihn verwiesen wird durch den Verschluss, so dass es nicht recycelt werden kann.

Eine weitere Sache: Schließung ist in Python kein einzigartiges Konzept. Alle Sprachen, die Funktionen als Bürger erster Klasse behandeln, haben das Konzept der Schließung. Allerdings können Abschlüsse auch in Sprachen wie Java verwendet werden, in denen Klassen erstklassige Bürger sind, sie müssen jedoch mithilfe von Klassen oder Schnittstellen implementiert werden.

Weitere konzeptionelle Informationen finden Sie unter dem Referenzlink am Ende.

2. Warum Verschlüsse verwenden

Aufgrund der obigen Einführung frage ich mich, ob die Leser das Gefühl haben, dass dieses Ding den Klassen etwas ähnelt. Die Ähnlichkeit besteht darin, dass beide eine Datenkapselung bereitstellen. Der Unterschied besteht darin, dass der Abschluss selbst eine Methode ist. Wie bei Klassen abstrahieren wir häufig gemeinsame Dinge in Klassen, wenn wir programmieren (und natürlich auch die reale Geschäftswelt modellieren), um gemeinsame Funktionen wiederzuverwenden. Das Gleiche gilt für Abschlüsse, wenn wir eine funktionsgranulare Abstraktion benötigen.

An diesem Punkt kann ein Abschluss als schreibgeschütztes Objekt verstanden werden. Sie können ihm eine Eigenschaft übergeben, es kann Ihnen jedoch nur eine Ausführungsschnittstelle bereitstellen. Daher benötigen wir in Programmen häufig ein solches Funktionsobjekt – den Abschluss –, um uns bei der Vervollständigung einer gemeinsamen Funktion zu helfen, wie z. B. dem Dekorator, der später erwähnt wird.

3. Verschlüsse verwenden

Das erste Szenario, ein sehr wichtiges und häufiges Verwendungsszenario in Python, ist der Dekorator. Python bietet einen sehr benutzerfreundlichen „syntaktischen Zucker“ für den Dekorator, der es uns ermöglicht, Dekoration sehr bequem zu verwenden Vieles zum Dekorationsprinzip. Kurz gesagt, wenn Sie @decorator_func zu einer Funktion func hinzufügen, entspricht dies decorator_func(func):

def decorator_func(func):
 def wrapper(*args, **kwargs):
  return func(*args, **kwargs)
 return wrapper

@decorator_func
def func(name):
 print 'my name is', name

# 等价于
decorator_func(func)

In diesem Beispiel des Dekorators enthält der Abschluss (Wrapper) den externen Funktionsparameter und kann von außen übergebene Parameter akzeptieren. Die empfangenen Parameter werden intakt an die Funktion übergeben und an die Ausführung zurückgegeben.

Dies ist ein einfaches Beispiel. Wenn es etwas komplizierter ist, können Sie mehrere Abschlüsse verwenden, z. B. den häufig verwendeten LRUCache-Dekorator. Der Dekorator kann Parameter wie @lru_cache(expire=500) akzeptieren. Die Implementierung ist die Verschachtelung zweier Abschlüsse:

def lru_cache(expire=5):
 # 默认5s超时
 def func_wrapper(func):
  def inner(*args, **kwargs):
   # cache 处理 bala bala bala
   return func(*args, **kwargs)
  return inner
 return func_wrapper

@lru_cache(expire=10*60)
def get(request, pk)
 # 省略具体代码
 return response()

Studenten, die nicht viel über Schließungen wissen, müssen in der Lage sein, den obigen Code zu verstehen. Dies ist eine Interviewfrage, die wir in früheren Interviews oft gestellt haben.

Das zweite Szenario basiert auf einer Funktion des Abschlusses – der „faulen Bewertung“. Diese Anwendung kommt häufiger beim Zugriff auf die Datenbank vor, zum Beispiel:

# 伪代码示意

class QuerySet(object):
 def __init__(self, sql):
  self.sql = sql
  self.db = Mysql.connect().corsor() # 伪代码

 def __call__(self):
  return db.execute(self.sql)

def query(sql):
 return QuerySet(sql)

result = query("select name from user_app")
if time > now:
 print result # 这时才执行数据库访问

Das obige unangemessene Beispiel zeigt die Funktion der verzögerten Auswertung durch Schließung, aber das von der obigen Abfrage zurückgegebene Ergebnis ist keine Funktion, sondern eine Klasse mit funktionalen Funktionen. Wenn Sie interessiert sind, können Sie sich die Implementierung des Abfragesatzes von Django ansehen. Das Prinzip ist ähnlich.

Das dritte Szenario ist die Situation, in der die Parameter einer bestimmten Funktion im Voraus zugewiesen werden müssen. Natürlich gibt es in Python bereits eine gute Lösung für den Zugriff auf functools.parial, aber dies kann auch mithilfe von Abschlüssen erreicht werden.

def partial(**outer_kwargs):
 def wrapper(func):
  def inner(*args, **kwargs):
   for k, v in outer_kwargs.items():
    kwargs[k] = v
   return func(*args, **kwargs)
  return inner
 return wrapper

@partial(age=15)
def say(name=None, age=None):
 print name, age

say(name="the5fire")
# 当然用functools比这个简单多了
# 只需要： functools.partial(say, age=15)(name='the5fire')

Es scheint, dass dies ein weiteres weit hergeholtes Beispiel ist, aber es kann als Übung der Anwendung von Verschlüssen angesehen werden.

Abschließend lässt sich sagen, dass Abschlüsse leicht zu verstehen sind und in Python häufig verwendet werden. Wenn Sie Fragen haben, hinterlassen Sie bitte eine Nachricht.

4. Referenzmaterialien

Wikipedia-Schließung

http://stackoverflow.com/questions/4020419/closures-in-python

http://www.shutupandship.com/2012/01/python-closures-explained.html

http://stackoverflow.com/questions/141642/what-limitations-have-closures-in-python-compared-to-lingual-x-closures

http://mrevelle.blogspot.com/2006/10/closure-on-closures.html