Python Advanced: Detaillierte Beschreibung von Funktionen höherer Ordnung

In diesem Artikel geht es um Python für Fortgeschrittene: Ausführliche Erläuterungen zu Funktionen höherer Ordnung finden Sie unter

Funktionale Programmierung

Funktion ist eine Art Kapselung, die von Pythons integrierten Funktionen unterstützt wird Durch die Aufteilung großer Codeabschnitte in Funktionen und den schichtweisen Aufruf von Funktionen können wir komplexe Aufgaben in einfache Aufgaben zerlegen. Diese Zerlegung kann als prozessorientierte Programmierung bezeichnet werden. Funktionen sind die Grundeinheit der prozessorientierten Programmierung.

Funktionale Programmierung (bitte beachten Sie das Zusatzwort „Formel“) – Funktionale Programmierung kann zwar auch der prozessorientierten Programmierung zugerechnet werden, ihre Ideen ähneln jedoch eher mathematischen Berechnungen.

Wir müssen zunächst die Konzepte von Computer und Computing verstehen.

Auf Computerebene führt die CPU Befehlscodes für Addition, Subtraktion, Multiplikation und Division sowie verschiedene bedingte Urteile und Sprunganweisungen aus. Daher ist die Assemblersprache die Sprache, die dem Computer am nächsten kommt.

Berechnung bezieht sich auf Berechnung im mathematischen Sinne. Je abstrakter die Berechnung, desto weiter entfernt ist sie von der Computerhardware.

Entsprechend den Programmiersprachen ist die Sprache auf niedrigerer Ebene näher am Computer, weist eine geringere Abstraktionsebene auf und weist eine höhere Ausführungseffizienz auf, z. B. ist die Sprache auf höherer Ebene näher am Computer. hat ein höheres Abstraktionsniveau und eine geringere Ausführungseffizienz, wie z. B. die Lisp-Sprache.

Funktionale Programmierung ist ein Programmierparadigma mit einem hohen Abstraktionsgrad. In rein funktionalen Programmiersprachen geschriebene Funktionen haben daher keine Variablen, solange die Eingabe sicher ist sicher. Diese reine Funktion soll keine Nebenwirkungen haben. In Programmiersprachen, die die Verwendung von Variablen zulassen, kann die gleiche Eingabe zu unterschiedlichen Ausgaben führen, da der Variablenstatus innerhalb der Funktion ungewiss ist. Daher hat diese Art von Funktion Nebenwirkungen.

Ein Merkmal der funktionalen Programmierung besteht darin, dass die Funktion selbst als Parameter an eine andere Funktion übergeben und eine Funktion zurückgegeben werden kann!

Python bietet teilweise Unterstützung für die funktionale Programmierung. Da Python die Verwendung von Variablen zulässt, ist Python keine rein funktionale Programmiersprache.

Funktion höherer Ordnung

Funktion höherer Ordnung heißt im Englischen Funktion höherer Ordnung. Was sind Funktionen höherer Ordnung? Wir verwenden echten Code als Beispiel, um die Konzepte Schritt für Schritt zu vertiefen.

Variablen können auf Funktionen verweisen

Nehmen Sie die in Python integrierte Absolutwertfunktion abs() als Beispiel, um diese Funktion aufzurufen:

> >> abs(-10)10

Aber was ist, wenn Sie nur Bauchmuskeln schreiben?

>>> abs

Es ist ersichtlich, dass abs(-10) ein Funktionsaufruf ist und abs ist die Funktion selbst.

Um das Ergebnis des Funktionsaufrufs zu erhalten, können wir das Ergebnis einer Variablen zuweisen:

>>> x = abs(-10)>>> >

Was aber, wenn die Funktion selbst einer Variablen zugewiesen wird?

>>> f = abs

>>> f

Fazit: Die Funktion selbst ist auch Kann Variablen zugewiesen werden, das heißt: Variablen können auf Funktionen verweisen.

Wenn eine Variable auf eine Funktion zeigt, kann die Funktion dann über die Variable aufgerufen werden? Überprüfen Sie es mit dem Code:

>>> f = abs>>>

Erfolg! Das bedeutet, dass die Variable f nun auf die abs-Funktion selbst zeigt. Der direkte Aufruf der Funktion abs() ist genau dasselbe wie der Aufruf der Variablen f().

Der Funktionsname ist auch eine Variable

Wie lautet also der Funktionsname? Der Funktionsname ist eigentlich die Variable, die auf die Funktion zeigt! Für die Funktion abs() kann der Funktionsname abs als Variable betrachtet werden, die auf eine Funktion verweist, die den Absolutwert berechnen kann!

Was passiert, wenn Bauchmuskeln auf andere Objekte zeigen?

>>> abs = 10

>>> abs(-10)
Traceback (letzter Aufruf zuletzt):
Datei „“ , Zeile 1, in
TypeError: 'int' object is not callable

Nachdem abs auf 10 gezeigt wurde, kann die Funktion nicht über abs(-10) aufgerufen werden! Denn die abs-Variable zeigt nicht mehr auf die Absolutwertfunktion, sondern auf eine Ganzzahl 10!

Natürlich darf der eigentliche Code nicht so geschrieben werden. Dies soll verdeutlichen, dass der Funktionsname auch eine Variable ist. Um die abs-Funktion wiederherzustellen, starten Sie die interaktive Python-Umgebung neu.

Hinweis: Da die abs-Funktion tatsächlich im Import-Builtins-Modul definiert ist, verwenden Sie importbuiltins.abs = 10, um den Zeiger der Abs-Variablen so zu ändern, dass er in anderen Modulen wirksam wird.

Funktion übergeben

Da Variablen auf Funktionen verweisen können und die Parameter von Funktionen Variablen empfangen können, kann eine Funktion eine andere Funktion als Parameter empfangen. Diese Art von Funktion wird als höhere Funktion bezeichnet. Bestellfunktion.

Die einfachste Funktion höherer Ordnung:

def add(x, y, f): return f(x) + f(y)

when When Wir rufen add(-5, 6, abs) auf, die Parameter x, y und f erhalten jeweils -5, 6 und abs. Gemäß der Funktionsdefinition können wir den Berechnungsprozess wie folgt ableiten:

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 🎜>
Überprüfen Sie es mit dem Code:

>>> add(-5, 6, abs)11

Das Schreiben einer Funktion höherer Ordnung bedeutet, dass die Parameter der Funktion können von anderen Funktionen empfangen werden.

Zusammenfassung

Übergabefunktionen als Parameter werden als Funktionen höherer Ordnung bezeichnet.

map/reduce

Python verfügt über integrierte Map()- und Reduce()-Funktionen.

Wenn Sie Googles berühmtes Papier „MapReduce: Simplified Data Processing on Large Clusters“ gelesen haben, können Sie das Konzept von Map/Reduce grob verstehen.

Schauen wir uns zuerst die Karte an. Die Funktion „map()“ empfängt zwei Parameter, einer ist eine Funktion und der andere ist eine iterierbare Karte, wendet die übergebene Funktion nacheinander auf jedes Element der Sequenz an und gibt das Ergebnis als neuen Iterator zurück.

Zum Beispiel haben wir eine Funktion f(x)=x2, und wir möchten diese Funktion auf eine Liste [1, 2, 3, 4, 5, 6, 7, 8, 9]. Sie können map() verwenden, um es wie folgt zu implementieren:

Jetzt verwenden wir Python-Code, um es zu implementieren:

>> > def f(x): ... return x * x

...>>> 9])>>> ; list(r)

[1, 4, 9, 16, 25, 36, 49, 64, 81]


Der erste übergebene Parameter map() ist f, das heißt Das Funktionsobjekt selbst. Da das Ergebnis r ein Iterator ist und Iterator eine Lazy-Sequenz ist, wird die Funktion list() verwendet, um die gesamte Sequenz berechnen und eine Liste zurückgeben zu können.

Sie denken vielleicht, dass Sie die Funktion „map()“ nicht benötigen. Sie können eine Schleife schreiben und das Ergebnis berechnen:

L = []für n in [1, 2, 3 , 4, 5, 6, 7, 8, 9]:

L.append(f(n))

print(L)


ist zwar möglich, aber aus dem Können Sie auf einen Blick verstehen, wie „f(x) auf jedes Element der Liste angewendet wird und als Ergebnis eine neue Liste generiert wird“?

map() als Funktion höherer Ordnung abstrahiert also tatsächlich die Operationsregeln. Daher können wir nicht nur einfache f(x)=x2 berechnen, sondern auch jede komplexe Funktion, wie zum Beispiel: Konvertieren Sie alle Zahlen in dieser Liste in Zeichenfolgen:

>>> 1‘, ‚2‘, ‚3‘, ‚4‘, ‚5‘, ‚6‘, ‚7‘, ‚8‘, ‚9‘]

Nur ​​eine Codezeile.

Schauen Sie sich die Verwendung von Reduzieren an. Reduce wendet eine Funktion auf eine Sequenz an [x1, x2, x3, ...]. Diese Funktion muss zwei Parameter erhalten. Reduce setzt die kumulative Berechnung des Ergebnisses mit dem nächsten Element der Sequenz fort 🎜>reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

Summieren Sie beispielsweise eine Sequenz kann Reduce verwenden, um Folgendes zu implementieren:

>>> from functools import Reduce>>> >> Reduce(add, [1, 3, 5, 7, 9])25

Natürlich kann die Summenoperation direkt mit der in Python integrierten Funktion sum() durchgeführt werden. Es besteht keine Notwendigkeit, Reduce zu verwenden.

Aber wenn Sie die Sequenz [1, 3, 5, 7, 9] in die Ganzzahl 13579 umwandeln möchten, kann Reduzieren nützlich sein:

>>> import Reduce>>> def fn(x, y):... return x * 10 + y

...>>> ]) 13579

Dieses Beispiel selbst ist nicht sehr nützlich, aber wenn wir bedenken, dass die Zeichenfolge str auch eine Sequenz ist, können wir das obige Beispiel leicht ändern und map() verwenden, um das zu schreiben Konvertierung der str-Funktion für int:

>>> from functools import Reduce>>>... return x * 10 + y
. .> ;>> def char2num(s):... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5 ': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

...>>> , ' 13579'))13579

ist in einer str2int-Funktion organisiert:

aus functools import Reducedef str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return Reduce( fn, map(char2num, s))

kann auch mit der Lambda-Funktion weiter vereinfacht werden:

from functools import reduziertef char2num(s): return {'0': 0 , '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, ' 9 ': 9}[s]def str2int(s): return Reduce(lambda x, y: x * 10 + y, map(char2num, s))

Mit anderen Worten, unter der Annahme von Python Wenn Sie die Funktion int() nicht bereitstellen, können Sie selbst eine Funktion schreiben, um eine Zeichenfolge in eine Ganzzahl umzuwandeln. Dafür sind nur wenige Codezeilen erforderlich!

Die Verwendung der Lambda-Funktion wird später vorgestellt.

filter

Pythons integrierte Funktion filter() wird zum Filtern von Sequenzen verwendet.

Ähnlich wie map() erhält auch filter() eine Funktion und eine Sequenz. Im Gegensatz zu map() wendet filter() die übergebene Funktion nacheinander auf jedes Element an und entscheidet dann, ob das Element beibehalten oder verworfen wird, je nachdem, ob der Rückgabewert True oder False ist.

Um beispielsweise in einer Liste gerade Zahlen zu löschen und nur ungerade Zahlen beizubehalten, können Sie schreiben:

def is_odd(n): return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))# Ergebnis: [1, 5, 9, 15]

Setzen Sie a Sequenz in Um die leere Zeichenfolge zu löschen, können Sie schreiben:

def not_empty(s): return s and s.strip()

list(filter(not_empty, ['A', ' ' , 'B', None, 'C', ' ']))# Ergebnis: ['A', 'B', 'C']

Es ist ersichtlich, dass je höher- Wenn die Funktion filter() verwendet wird, besteht der Schlüssel darin, eine „Filter“-Funktion korrekt zu implementieren.

Beachten Sie, dass die Funktion filter() einen Iterator zurückgibt, bei dem es sich um eine verzögerte Sequenz handelt. Um filter() also zu zwingen, die Berechnungsergebnisse abzuschließen, müssen Sie die Funktion list() verwenden, um alle Ergebnisse zu erhalten und die Liste zurückgeben.

sortiert

Sortieralgorithmus

Sortieren ist ebenfalls ein Algorithmus, der häufig in Programmen verwendet wird. Unabhängig davon, ob Blasensortierung oder Schnellsortierung verwendet wird, besteht der Kern der Sortierung darin, die Größe zweier Elemente zu vergleichen. Wenn es eine Zahl ist, können wir sie direkt vergleichen, aber was ist, wenn es eine Zeichenfolge oder zwei Diktate ist? Der direkte Vergleich mathematischer Größen ist bedeutungslos, daher muss der Vergleichsprozess durch Funktionen abstrahiert werden.

Pythons integrierte Funktion sorted() kann die Liste sortieren:

>>> sorted([36, 5, -12, 9, -21])[- 21 , -12, 5, 9, 36]

Darüber hinaus ist die Funktion sorted() auch eine Funktion höherer Ordnung. Sie kann auch eine Schlüsselfunktion erhalten, um eine benutzerdefinierte Sortierung zu implementieren, z. B. nach absolute Wertgrößensortierung:

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21 , 36 ]

Die durch key angegebene Funktion wirkt sich auf jedes Element der Liste aus und wird entsprechend dem von der key-Funktion zurückgegebenen Ergebnis sortiert. Vergleichen Sie die Originalliste und die mit key=abs verarbeitete Liste:

list = [36, 5, -12, 9, -21]keys = [36, 5, 12, 9, 21]

Dann sortiert die Funktion sorted() nach Schlüsseln und gibt die entsprechenden Elemente der Liste entsprechend der entsprechenden Beziehung zurück:

keys sorting result => [5, 9, 12, 21, 36 ]
                                                                                                                                                           >
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])['Credit', 'Zoo', 'about', 'bob' ]

Standardmäßig basiert die Zeichenfolgensortierung auf dem ASCII-Größenvergleich. Da „Z“

Jetzt schlagen wir vor, dass die Sortierung die Groß-/Kleinschreibung ignorieren und in alphabetischer Reihenfolge sortieren sollte. Um diesen Algorithmus zu implementieren, müssen keine größeren Änderungen am vorhandenen Code vorgenommen werden, solange wir eine Schlüsselfunktion verwenden können, um die Zeichenfolge einer Sortierung zuzuordnen, bei der die Groß- und Kleinschreibung ignoriert wird. Der Vergleich zweier Zeichenfolgen unter Ignorieren der Groß-/Kleinschreibung bedeutet eigentlich, die Zeichenfolgen zunächst in Großbuchstaben (oder Kleinbuchstaben) umzuwandeln und sie dann zu vergleichen.

Auf diese Weise übergeben wir die Schlüsselfunktion an sorted, um eine Sortierung zu erreichen, die die Groß-/Kleinschreibung ignoriert:

>>> , 'Credit'], key=str.lower)

['about', 'bob', 'Credit', 'Zoo']

Um die Sortierung umzukehren, sind keine Änderungen erforderlich Funktion können Sie den dritten Parameter reverse=True übergeben:

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str. Lower , reverse=True)
['Zoo', 'Credit', 'bob', 'about']

Wie aus den obigen Beispielen ersichtlich ist, ist die Abstraktionsfähigkeit höherer Ordnung Die Funktionen sind sehr leistungsstark und der Kerncode kann sehr einfach gehalten werden.

Zusammenfassung

sorted() ist ebenfalls eine Funktion höherer Ordnung. Der Schlüssel zum Sortieren mit sorted() liegt in der Implementierung einer Zuordnungsfunktion.

Rückgabefunktion

Funktion als Rückgabewert

Funktionen höherer Ordnung können nicht nur Funktionen als Parameter akzeptieren, sondern auch Funktionen als Ergebniswerte zurückgeben.

Lassen Sie uns die Summierung eines variablen Parameters implementieren. Normalerweise ist die Summationsfunktion wie folgt definiert:

def calc_sum(*args):
ax = 0 für n in args:
ax = ax + n return ax

Was aber, wenn die Summe nicht sofort berechnet werden muss, sondern nach Bedarf im nachfolgenden Code berechnet wird? Anstatt das Summationsergebnis zurückzugeben, können Sie die Summationsfunktion zurückgeben:

def lazy_sum(*args): def sum():
ax = 0 for n in args:
ax = ax + n return ax return sum

Wenn wir lazy_sum() aufrufen, wird nicht das Summierungsergebnis zurückgegeben, sondern die Summationsfunktion:

>>> (1, 3, 5, 7, 9)
>>> f
.sum at 0x101c6ed90>

Das Ergebnis von Die Summe wird tatsächlich berechnet, wenn die Funktion f aufgerufen wird:

>>> f()25

In diesem Beispiel definieren wir sie in der Funktion lazy_sum, Funktion sum , und die interne Funktionssumme kann auf die Parameter und lokalen Variablen der externen Funktion lazy_sum verweisen. Wenn lazy_sum die Funktionssumme zurückgibt, werden die relevanten Parameter und Variablen in der zurückgegebenen Funktion gespeichert. Dies wird als „Abschluss“ bezeichnet Leistung.

Bitte beachten Sie noch etwas: Wenn wir lazy_sum() aufrufen, gibt jeder Aufruf eine neue Funktion zurück, auch wenn dieselben Parameter übergeben werden:

>>> lazy_sum(1, 3, 5, 7, 9)>>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> >Die Aufrufergebnisse von f1() und f2() beeinflussen sich gegenseitig nicht.

Abschluss

Beachten Sie, dass die zurückgegebene Funktion in ihrer Definition auf die lokalen Variablen args verweist. Wenn eine Funktion eine Funktion zurückgibt, werden daher auch ihre internen lokalen Variablen referenziert Der Verschluss ist einfach zu verwenden, aber nicht einfach umzusetzen.

Ein weiteres zu beachtendes Problem besteht darin, dass die zurückgegebene Funktion nicht sofort ausgeführt wird, sondern erst ausgeführt wird, wenn f() aufgerufen wird. Schauen wir uns ein Beispiel an:

def count():

fs = [] for i in range(1, 4): def f(): return i*i

fs.append( f) fs zurückgeben

f1, f2, f3 = count()


Im obigen Beispiel wird bei jeder Schleife eine neue Funktion erstellt und dann das erstellte Ganze Drei Funktionen sind zurückgekehrt.

Sie denken vielleicht, dass die Ergebnisse des Aufrufs von f1(), f2() und f3() 1, 4, 9 sein sollten, aber die tatsächlichen Ergebnisse sind:

>>> ; f1() 9>>> f2()9>>> f3()9

Alle sind 9! Der Grund dafür ist, dass die zurückgegebene Funktion auf die Variable i verweist, diese aber nicht sofort ausgeführt wird. Wenn alle drei Funktionen zurückkehren, ist die Variable i, auf die sie sich beziehen, zu 3 geworden, sodass das Endergebnis 9 ist.

Bei der Rückgabe eines Abschlusses ist Folgendes zu beachten: Die Rückgabefunktion sollte keine Schleifenvariablen oder Variablen referenzieren, die sich später ändern.

Was passiert, wenn Sie auf eine Schleifenvariable verweisen müssen? Die Methode besteht darin, eine weitere Funktion zu erstellen und die Parameter der Funktion zu verwenden, um den aktuellen Wert der Schleifenvariablen zu binden. Unabhängig davon, wie sich die Schleifenvariable anschließend ändert, bleibt der an den Funktionsparameter gebundene Wert unverändert:

def count(): def f(j):               def g():                                                                   ’ to ’ s. ’ s ’ s ‐ ‐ ‐                                                             to  ) wird sofort ausgeführt, sodass der aktuelle Wert von i an f() übergeben wird, return fs

Sehen Sie sich das Ergebnis noch einmal an:

>>> f1, f2, f3 = count()>>> )4>>> f3()9

Der Nachteil ist, dass der Code länger ist und die Lambda-Funktion verwendet werden kann. Verkürzen Sie den Code.

Zusammenfassung

Eine Funktion kann ein Berechnungsergebnis oder eine Funktion zurückgeben.

Bedenken Sie bei der Rückgabe einer Funktion, dass die Funktion nicht ausgeführt wird, und verweisen Sie nicht auf Variablen, die sich in der zurückgegebenen Funktion ändern könnten.

Anonyme Funktion

Wenn wir eine Funktion übergeben, müssen wir die Funktion manchmal nicht explizit definieren. Es ist bequemer, die anonyme Funktion direkt zu übergeben.

In Python gibt es begrenzte Unterstützung für anonyme Funktionen. Nehmen wir immer noch die Funktion map() als Beispiel: Bei der Berechnung von f(x)=x2 können Sie zusätzlich zur Definition einer Funktion von f(x) auch direkt eine anonyme Funktion übergeben:

> >> list (map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))[1, 4, 9, 16, 25, 36, 49 , 64, 81]

Wie aus dem Vergleich hervorgeht, ist die anonyme Funktion Lambda x: x * x tatsächlich:

def f(x): return x * x

Das Schlüsselwort Lambda repräsentiert eine anonyme Funktion und das x vor dem Doppelpunkt repräsentiert Funktionsparameter.

Anonyme Funktionen haben eine Einschränkung, das heißt, sie können nur einen Ausdruck haben. Es ist nicht erforderlich, einen Rückgabewert zu schreiben.

Die Verwendung anonymer Funktionen bietet einen Vorteil, da die Funktion keinen Namen hat, sodass Sie sich keine Sorgen über Funktionsnamenkonflikte machen müssen. Darüber hinaus ist die anonyme Funktion auch ein Funktionsobjekt. Sie können die anonyme Funktion auch einer Variablen zuweisen und diese dann zum Aufrufen der Funktion verwenden:

>>> * x
>>> f

>>> f(5)

In ähnlicher Weise können Sie anonyme Funktionen als Rückgabewerte zurückgeben, zum Beispiel:

def build(x, y): return lambda: x * x + y * y

Summary

Python bietet nur begrenzte Unterstützung für anonyme Funktionen und nur einige einfache Situationen können anonyme Funktionen verwenden.

Teilfunktion

Das Functools-Modul von Python bietet viele nützliche Funktionen, darunter eine Teilfunktion. Es ist zu beachten, dass sich die Teilfunktion hier von der Teilfunktion im mathematischen Sinne unterscheidet.

Bei der Einführung von Funktionsparametern haben wir erwähnt, dass durch Festlegen der Standardwerte von Parametern die Schwierigkeit des Funktionsaufrufs verringert werden kann. Teilfunktionen können dies auch tun. Beispiel:

Die Funktion int() kann eine Zeichenfolge in eine Ganzzahl umwandeln. Wenn nur eine Zeichenfolge übergeben wird, verwendet die Funktion int() standardmäßig die Dezimalkonvertierung:

>> > int('12345')12345

Aber die Funktion int() stellt auch einen zusätzlichen Basisparameter bereit, der Standardwert ist 10. Wenn Sie den Basisparameter übergeben, können Sie eine N-Basis-Konvertierung durchführen:

>>> ' 12345', 16)74565

Unter der Annahme, dass wir eine große Anzahl binärer Zeichenfolgen konvertieren möchten, ist es sehr mühsam, jedes Mal int(x, base=2) zu übergeben, so dachten wir Damit wir eine int2( )-Funktion definieren können, wird standardmäßig base=2 übergeben:

def int2(x, base=2): return int(x, base)

Auf diese Weise konvertieren wir binär Sehr praktisch:

>>> int2('1000000')64>>> int2('1010101')85

functools.partial soll uns helfen, eine Teilfunktion zu erstellen. Wir müssen int2() nicht selbst definieren. Wir können den folgenden Code direkt verwenden, um eine neue Funktion int2 zu erstellen:

>>> ;import functools>>> int2('1010101')85

Eine kurze Zusammenfassung von functools.partial Die Funktion besteht darin, bestimmte Parameter einer Funktion festzulegen (dh Standardwerte festzulegen) und eine neue Funktion zurückzugeben. Es wird einfacher sein, diese neue Funktion aufzurufen.

Beachten Sie, dass die neue int2-Funktion oben nur den Basisparameter auf den Standardwert 2 zurücksetzt, aber beim Aufruf der Funktion können auch andere Werte übergeben werden:

>> ; > int2('1000000', base=10)1000000

Schließlich können Sie beim Erstellen einer Teilfunktion tatsächlich drei Parameter erhalten: Funktionsobjekt, *args und **kw in :

int2 = functools.partial(int, base=2)

legt tatsächlich die Schlüsselwortparameterbasis der int()-Funktion fest, das heißt:

int2('10010')

entspricht:

kw = { 'base': 2 }int('10010', **kw)

Wenn Folgendes übergeben wird:

max2 = functools.partial(max, 10)

fügt tatsächlich automatisch 10 links als Teil von *args hinzu, das heißt:

max2(5, 6, 7)

entspricht:

args = (10, 5, 6, 7)

max(* args )

Das Ergebnis ist 10.

Zusammenfassung

Wenn eine Funktion zu viele Parameter hat und vereinfacht werden muss, können Sie functools.partial verwenden, um eine neue Funktion zu erstellen. Diese neue Funktion kann einige der Parameter des Originals korrigieren Funktion, daher ist es einfacher beim Aufrufen.

Das obige ist der detaillierte Inhalt vonPython Advanced: Detaillierte Beschreibung von Funktionen höherer Ordnung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!