Beispiele für die Verwendung von Abschlüssen in Python

In diesem Artikel werden hauptsächlich die relevanten Informationen zur Verwendung von Abschlüssen im Python-Grundlagen-Tutorial vorgestellt. Ich hoffe, dass dieser Artikel Ihnen helfen kann.

Python-Grundlagen-Tutorial Abschlüsse verwenden

Vorwort:

Abschlüsse (Closure) sind eine wichtige grammatikalische Struktur in der funktionalen Programmierung. Funktionale Programmierung ist ein Programmierparadigma (und prozedurale Programmierung und objektorientierte Programmierung sind ebenfalls Programmierparadigmen). Bei der prozessorientierten Programmierung haben wir Funktionen gesehen; bei der objektorientierten Programmierung haben wir Objekte gesehen. Der grundlegende Zweck von Funktionen und Objekten besteht darin, Code auf eine bestimmte logische Weise zu organisieren und die Wiederverwendbarkeit des Codes zu verbessern. Der Abschluss ist auch eine Struktur zum Organisieren von Code, wodurch auch die Wiederverwendbarkeit des Codes verbessert wird.

Verschiedene Sprachen implementieren Abschlüsse auf unterschiedliche Weise. Python basiert auf Funktionsobjekten und bietet Unterstützung für die Syntaxstruktur von Abschlüssen (wir haben oft gesehen, dass Python Objekte verwendet, um eine spezielle Syntax in speziellen Methoden und Multiparadigmen zu implementieren). Alles in Python ist ein Objekt, und die grammatikalische Struktur der Funktion ist ebenfalls ein Objekt. In einem Funktionsobjekt verwenden wir das Funktionsobjekt wie ein normales Objekt, indem wir beispielsweise den Namen des Funktionsobjekts ändern oder das Funktionsobjekt als Parameter übergeben.

Umfang des Funktionsobjekts

Wie andere Objekte hat auch das Funktionsobjekt seinen Überlebensbereich, der der Umfang des Funktionsobjekts ist. Funktionsobjekte werden mithilfe von Def-Anweisungen definiert, und der Umfang des Funktionsobjekts entspricht der Ebene, auf der sich Def befindet. Im folgenden Code kann beispielsweise die Funktionszeile, die wir innerhalb des Zugehörigkeitsbereichs der Funktion line_conf definieren, nur innerhalb des Zugehörigkeitsbereichs von line_conf aufgerufen werden.

def line_conf():
  def line(x):
    return 2*x+1
  print(line(5))  # within the scope


line_conf()
print(line(5))    # out of the scope

Die Linienfunktion definiert eine gerade Linie (y = 2x + 1). Wie Sie sehen können, kann die Funktion line in line_conf() aufgerufen werden, aber der Aufruf von line außerhalb des Gültigkeitsbereichs führt zu folgendem Fehler:

NameError: name 'line' is not defined

bedeutet das hier Zeit Schon außerhalb des Geltungsbereichs.

Wenn Sie Lambda zum Definieren einer Funktion verwenden, entspricht der Umfang des Funktionsobjekts in ähnlicher Weise der Ebene, auf der sich das Lambda befindet.

Abschluss

Die Funktion ist ein Objekt und kann daher als Rückgabeergebnis einer bestimmten Funktion verwendet werden.

def line_conf():
  def line(x):
    return 2*x+1
  return line    # return a function object

my_line = line_conf()
print(my_line(5))

Der obige Code kann erfolgreich ausgeführt werden. Das Rückgabeergebnis von line_conf wird dem Linienobjekt zugewiesen. Der obige Code gibt 11 aus.

Was passiert, wenn in der Definition von line() auf eine externe Variable verwiesen wird?

def line_conf():
  b = 15
  def line(x):
    return 2*x+b
  return line    # return a function object

b = 5
my_line = line_conf()
print(my_line(5))

Wir können sehen, dass die übergeordnete Variable b im durch Zeile definierten untergeordneten Programmblock referenziert wird, die b-Informationen jedoch außerhalb der Definition von Zeile vorhanden sind ( b Die Definition von steht nicht im untergeordneten Block der Zeile). Wir nennen b die Umgebungsvariable von line. Wenn line als Rückgabewert von line_conf verwendet wird, enthält line tatsächlich bereits den Wert von b (obwohl b nicht mit line verknüpft ist).

Der obige Code gibt 25 aus, das heißt, der b-Wert, auf den in der Zeile verwiesen wird, ist der b-Wert , der als Referenz verfügbar ist, wenn das Funktionsobjekt definiert ist, und nicht der b-Wert, wenn er verwendet wird.

Eine Funktion und ihre Umgebungsvariablen bilden zusammen einen

Abschluss. In Python ist der sogenannte Abschluss ein Funktionsobjekt, das den Wert einer Umgebungsvariablen enthält. Umgebungsvariablenwerte werden im __closure__-Attribut des Funktionsobjekts gespeichert. Beispielsweise enthält der folgende Code:

def line_conf():
  b = 15
  def line(x):
    return 2*x+b
  return line    # return a function object

b = 5
my_line = line_conf()
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)

__closure__ ein Tupel. Jedes Element in diesem Tupel ist ein Objekt vom Typ Zelle. Wir sehen, dass die erste Zelle die Ganzzahl 15 enthält, was der Wert der Umgebungsvariablen b ist, als wir den Abschluss erstellt haben.

Schauen wir uns ein praktisches Beispiel für einen Abschluss an:

def line_conf(a, b):
  def line(x):
    return ax + b
  return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))

In diesem Beispiel bilden die Funktionszeile und die Umgebungsvariablen a und b einen Abschluss . Beim Erstellen des Abschlusses geben wir die Werte dieser beiden Umgebungsvariablen über die Parameter a und b von line_conf an. Auf diese Weise bestimmen wir die endgültige Form der Funktion (y = x + 1 und y = 4x + 5). . Wir müssen nur die Parameter a und b transformieren, um unterschiedliche gerade Ausdrucksfunktionen zu erhalten. Daraus können wir ersehen, dass Schließungen auch die Wirkung haben, die Wiederverwendbarkeit von Code zu verbessern.

Wenn es keinen Abschluss gibt, müssen wir jedes Mal, wenn wir eine Geradenfunktion erstellen, a, b, x angeben. Auf diese Weise müssen wir mehr Parameter übergeben und die Portabilität des Codes verringern. Mit Verschlüssen schaffen wir tatsächlich Funktionales. Die Linienfunktion definiert eine Funktion im weitesten Sinne. Einige Aspekte dieser Funktion sind bereits bestimmt (es muss eine gerade Linie sein), andere Aspekte (z. B. die Parameter a und b sind jedoch unbestimmt). Anschließend ermitteln wir die finale Funktion in Form eines Abschlusses anhand der von line_conf übergebenen Parameter.

Abschlüsse und Paralleloperationen

Abschlüsse reduzieren effektiv die Anzahl der Parameter, die für eine Funktion definiert werden müssen. Dies hat wichtige Auswirkungen auf den Parallelbetrieb. In einer parallelen Computerumgebung können wir jeden Computer für eine Funktion verantwortlich machen und dann die Ausgabe eines Computers mit der Eingabe des nächsten Computers verketten. Letztlich arbeiten wir wie am Fließband, mit Dateneingabe an einem Ende einer Reihe von Computerclustern und Datenausgabe am anderen Ende. Diese Situation eignet sich am besten für Funktionen mit nur einer Parametereingabe. Verschlüsse können diesen Zweck erreichen.

Parallel Computing entwickelt sich zu einem Hotspot. Dies ist auch ein wichtiger Grund, warum funktionale Programmierung wieder populär wird. Funktionale Programmierung gab es bereits in den 1950er Jahren, sie war jedoch nicht weit verbreitet. Der oben beschriebene Pipeline-Work-Parallel-Clustering-Prozess eignet sich jedoch perfekt für die funktionale Programmierung. Aufgrund der natürlichen Vorteile der funktionalen Programmierung unterstützen immer mehr Sprachen das Paradigma der funktionalen Programmierung.

Das obige ist der detaillierte Inhalt vonBeispiele für die Verwendung von Abschlüssen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!