So verwenden Sie verschachtelte Funktionen in Python

Dieser Artikel behandelt eine Anleitung zur Verwendung verschachtelter Funktionen in Python. In anderen Python -Funktionen werden verschachtelte Funktionen oder innere Funktionen definiert. Sie sind in bestimmten Programmiermustern und Anwendungsfällen nützlich. Einige von ihnen werden in diesem Artikel erklärt. Alle Codeproben in diesem Artikel werden mit Python 3 getestet.9.5 auf Ubuntu 21.04.

Über verschachtelte / innere Funktionen

Verschachtelte Funktionen sind, wie der Name schon sagt, Python -Funktionen, die in anderen Python -Funktionen erstellt werden. Neben ihrem eigenen Umfang hat die innere Funktion Zugriff auf die im Bereich der äußeren Funktion verfügbaren Objekte. Die innere Funktion kann als einzelnes Python -Objekt mit eigenen Daten und Variablen bezeichnet werden. Diese innere Funktion wird durch die äußere Funktion geschützt und kann nicht aufgerufen oder aus dem globalen Bereich genannt werden. Auf diese Weise fungiert die innere Funktion als verborgene Einheit, die nur innerhalb der Grenzen der äußeren Funktion arbeitet, und der globale Umfang ist sich dessen nicht bewusst. Dieser Prozess wird auch als „Kapselung“ in der Programmierung bezeichnet. Hier ist ein Beispiel für eine verschachtelte Funktion in Python.

Def Visibile_outer_function (Name):
Def Hidden_inner_function ():
Druck (Name)
Hidden_inner_function ()
Visibile_outer_function ("John")
Hidden_inner_function ()

Die äußere Funktion nimmt ein obligatorisches Argument namens "Name" auf. Die innere Funktion hat Zugriff auf den Umfang der äußeren Funktion, damit die Namensvariable verwendet werden kann. Ein Aufruf zur inneren Funktion wird dann in der äußeren Funktion gemacht. Als nächstes wird im globalen Umfang ein Aufruf sowohl der inneren als auch der äußeren Funktionen getätigt. Nachdem Sie das obige Code -Beispiel ausgeführt haben, sollten Sie die folgende Ausgabe erhalten:

John
Traceback (letzte Anruflast):
Datei "Main.py ", Zeile 9, in
Hidden_inner_function ()
NameError: Name 'Hidden_inner_Function' ist nicht definiert

Wie Sie in der Ausgabe sehen können, funktioniert die äußere Funktion gut, wenn Sie sie von Global Scope aufrufen. Ein Fehler wird geworfen, wenn Sie versuchen, die innere Funktion aufzurufen, da dies im globalen Bereich nicht verfügbar ist.

Innenfunktionen Anwendungsfälle

Jetzt, da Sie ein gewisses Verständnis für verschachtelte Funktionen haben, wundern Sie sich möglicherweise über ihren Nutzen und wann Sie sie verwenden müssen. Eine der häufigsten Verwendungen innerer Funktionen ist die Erstellung von Helferfunktionen innerhalb der Hauptfunktion. Innenfunktionen können auch als Dekorateure verwendet werden und können zur Implementierung von Schließungen in Ihrem Programm verwendet werden. Diese Anwendungsfälle werden nachstehend mit Beispielen erläutert.

Erstellen einer Helferfunktion

Helferfunktionen sind wie jede andere Python -Funktionen, aber sie werden als „Helfer“ -Funktionen bezeichnet, da sie dazu beitragen können, komplexen Code besser zu organisieren und in jeder Fälle wiederverwendet zu werden, um die Wiederholung von Code zu vermeiden. Unten finden Sie ein Code -Beispiel, das eine innere Helferfunktion veranschaulicht.

Def get_ticket_price (Name):
Mitglieder = ["Tony", "Peter", "Mark"]
Preis = 10
Def get_discounted_price (Rabatt = 1.0):
Rückgabe (Preis * Rabatt)
Wenn Name in Mitgliedern:
TICKE_PRICE = get_discounted_price (Rabatt = 0.50)
anders:
TICKE_PRICE = get_discounted_price ()
print ("Ticketpreis für" + name + "ist: $" + str (Ticket_price))
get_ticket_price ("Tony")
get_ticket_price ("John")

Die wichtigste äußere äußere Funktion lautet "get_ticket_price". Es nennt den Namen einer Person als obligatorische Argumentation. Die Funktion "get_discounted_price" ist eine innere Helferfunktion, die "Rabatt" als optionales Argument nimmt. Die Liste „Mitglieder“ enthält Namen aller registrierten Mitglieder, die für einen Rabatt berechtigt sind. Ein ermäßigter Preis für Mitglieder wird berechnet, indem die innere Funktion aufgerufen und mit einem Rabattwert als Argument geliefert wird. Diese Helferfunktion kann mehrmals basierend auf den Anforderungen aufgerufen werden, und Sie können auch die Logik innerhalb der inneren Funktion ändern. Mit inneren Helferfunktionen können Sie den Code vereinfachen und unnötige Wiederholungen vermeiden. Nachdem Sie das obige Code -Beispiel ausgeführt haben, sollten Sie die folgende Ausgabe erhalten:

Ticketpreis für Tony ist: $ 5.0
Ticketpreis für John ist: $ 10.0

Wie Sie in der obigen Ausgabe sehen können, erhält Tony einen Rabatt auf den Ticketpreis, da er in der Mitgliederliste ist.

Schließungen implementieren

Schließungen sind Fälle von inneren Funktionen, die durch äußere Funktionen zurückgegeben werden. Diese inneren Funktionen haben Zugriff auf den Umfang der äußeren Funktionen und sie haben weiterhin Zugriff auf den Umfang der äußeren Funktion. Schauen Sie sich das Code -Beispiel unten an:

Def get_discounted_price (Preis):
Def diskonted_price (Rabatt):
Rückgabepreis * Rabatt
return reconted_price
First_discount = get_discounted_price (10)
Second_discount = get_discounted_price (10)
print (first_discount (0.50)))
print (Second_discount (0).60)))

Die äußere Funktion "get_discounted_price" gibt eine Referenz auf die innere Funktion "Rabatted_Price" zurück. Beachten Sie, dass die Funktion in der Rückgabeerklärung ohne Zahnspangen aufgerufen wird. Als nächstes werden zwei neue Instanzen mit dem Namen "First_Discount" und "Second_Dicount" erstellt, indem die äußere Funktion aufgerufen wird, und ein Wert für das Argument "Preis" wird diesen Anrufen geliefert. Zu diesem Zeitpunkt wurde die äußere Funktion ausgeführt, aber sein Zustand wurde in den Objekten First_discount und Second_discount gespeichert. Wenn Sie nun die Instanzen von First_Discount und Second_Discount mit Klammern und Argumenten anrufen, haben sie bereits Zugriff auf eine Variable, die als Preis bezeichnet wird. Das Argument, das diesen Fällen geliefert wird, geht nun der inneren Funktion, die dann ein Ergebnis zurückgibt.

Nachdem Sie das obige Code -Beispiel ausgeführt haben, sollten Sie die folgende Ausgabe erhalten:

5.0
6.0

Schließungen werden in der Regel in Situationen verwendet, in denen Ihr Programm den Zustand einer Funktion bewahrt hat.

Dekorationsfunktionen erstellen

Dekorateurfunktionen in Python ändern das Verhalten einer vorhandenen Python -Funktion, ohne sie zu ändern. Wenn Sie also einen Dekorator an eine Funktion anbringen, können Sie der Funktion zusätzliche Funktionen hinzufügen oder sein Verhalten ändern, während Sie sein ursprüngliches Verhalten intakt halten. Ein typischer Python -Dekorateur sieht folgendermaßen aus:

@Dekorateur
Def dekoriert ():
passieren

Hier ändert „@Decorator“ das Verhalten der „dekorierten“ Funktion. Sie können Dekorateurfunktionen mit verschachtelten Funktionen erstellen. Um einen Dekorateur zu erstellen, definieren Sie eine Funktion und geben Sie sie an eine äußere Funktion als Argument weiter. Diese übergebene Funktion wird dann in einer anderen inneren Funktion aufgerufen, in der Sie sie verwenden und Logik implementieren können. Schließlich gibt die äußere Funktion die innere Funktion zurück, die das modifizierte Verhalten enthält. Schauen Sie sich das Code -Beispiel unten an.

Def get_discounted_price (Betrag):
Def diskonted_price ():
Preis = Betrag ()
new_price = Preis * 0.50
RECHTE NEW_PRICE
return reconted_price

Die äußere Funktion "get_discounted_price" wird eine andere Funktion als "Betrag" als Argument übergeben. Die innere Funktion nutzt die bestandene Funktion und fügt ihr ein bestimmtes Verhalten hinzu. Die äußere Funktion gibt dann einen Verweis auf die innere Funktion zurück, die das modifizierte Verhalten enthält. Nachdem Sie den Dekorateur definiert haben, können Sie das auf folgende Weise anrufen:

@get_discounted_price
Def get_price ():
Rückkehr 10
print (get_price ())

Dekoratoren sind an Funktionen gebunden, deren Verhalten Sie ändern möchten. Sie beginnen immer mit dem Symbol "@". Durch die Verwendung des Dekors hier übergeben Sie die Funktion "get_price" an die Funktion "get_discounted_price" als Argument. Wenn Sie nun die Funktion get_price anrufen, werden Sie nicht 10 als Ausgabe erhalten, aber eine vom Dekorator get_discounted_price geänderte Zahl, die geändert wird. Nachdem Sie das obige Code -Beispiel ausgeführt haben, sollten Sie die folgende Ausgabe erhalten:

5.0

Die oben gezeigte Dekorationsnutzung entspricht dem folgenden Code:

Def get_discounted_price (Betrag):
Def diskonted_price ():
Preis = Betrag ()
new_price = Preis * 0.50
RECHTE NEW_PRICE
return reconted_price
Def get_price ():
Rückkehr 10
Final_price = get_discounted_price (get_price)
print (Final_price ())

Anstatt eine "@Decorator" -Syntax als Kurzform zu verwenden, können Sie einfach eine neue Instanz der äußeren Funktion erstellen und eine weitere Funktion als Argument liefern. Das Endergebnis beider Codierungsmuster ist das gleiche. Da Dekorateure das Verhalten der ursprünglichen Funktion intakt halten, sind sie sehr nützlich, wenn Sie sie von Fall zu Fall auf der Basis aufrufen und gleichzeitig die Vanille -Implementierung einer dekorierten Funktion bewahren möchten.

Abschluss

Sie können verschachtelte Funktionen auf verschiedene Weise verwenden, um innere Funktionen zu erstellen, die der äußeren Funktion zusätzliche Funktionen und Logik verleihen. Einige der häufigsten Anwendungsfälle für verschachtelte Funktionen wurden im Artikel erläutert. Sie können auch Ihre eigenen Implementierungen innerer Funktionen erstellen, da alle Funktionen in Python als erstklassige Objekte behandelt werden und sie als Argumente zurückgegeben oder bestanden werden können.