Hallo Habrowsk. Wir haben vor Beginn des Python Developer- Kurses eine Übersetzung eines weiteren nützlichen Materials vorbereitet .
Python ist eine objektorientierte Programmiersprache auf hoher Ebene. Einer der größten Vorteile von Python besteht darin, dass es über eine spezielle Funktionalität verfügt, mit der Sie wiederverwendbaren Code mit den integrierten Sprachtools schreiben können.Functools ist eine Python-Bibliothek, die für Funktionen höherer Ordnung ausgelegt ist. Solche Funktionen können andere Funktionen übernehmen und Funktionen zurückgeben. Sie helfen dem Entwickler, Code zu schreiben, der wiederverwendet werden kann. Funktionen können verwendet oder erweitert werden, ohne sie vollständig neu zu schreiben. Das functools- Modul in Python bietet verschiedene Tools, mit denen Sie den beschriebenen Effekt erzielen können. Zum Beispiel Folgendes:- Teilweise
- Vollständige Bestellung;
update_wrapperfür teilweise .
Die Teilfunktion ist eines der Hauptwerkzeuge von functools . Lassen Sie es uns anhand von Beispielen herausfinden.Feature teilweise in Python
Im functools- Modul wird die Teilfunktion als eines der wichtigsten Werkzeuge angesehen. Mit einer Teilfunktion können Sie eine vorhandene Funktion ersetzen, der bereits Argumente übergeben wurden. Darüber hinaus können wir auch eine neue Version der Funktion erstellen, indem wir eine Qualitätsdokumentation hinzufügen.Wir können neue Funktionen erstellen, indem wir Teilargumente übergeben. Wir können auch einige Funktionsargumente einfrieren, die zum Erscheinen eines neuen Objekts führen. Eine andere Möglichkeit, teilweise darzustellen , besteht darin, dass wir mit ihrer Hilfe eine Funktion mit Standardwerten erstellen können. Partial unterstützt Schlüsselwörter und Positionsargumente als fest.Schauen wir uns Beispiele an.Wie erstelle ich eine Teilfunktion ?
Verwenden Sie
zum Erstellen einer Teilfunktion Funktionswerkzeuge partial()aus der Bibliothek . Es ist wie folgt geschrieben:partial(func, /, *args, ** kwargs)
Sie erstellen also eine Teilfunktion , die func aufruft und feste Schlüsselwörter und Positionsargumente übergibt. Hier werden normalerweise einige notwendige Argumente übergeben, um die Funktion func aufzurufen . Die restlichen Argumente werden in * args und ** kwargs übergeben .Angenommen, die folgende Funktion fügt zwei Zahlen hinzu:def multiply(x, y):
return x * y
Betrachten Sie nun den Fall, in dem wir eine bestimmte Zahl verdoppeln oder verdreifachen mussten. In diesem Fall definieren wir neue Funktionen wie folgt:def multiply(x, y):
return x * y
def doubleNum(x):
return multiply(x, 2)
def tripleNum(x):
return multiply(x, 3)
Wenn das Skript der Funktion nur 2-3 ist, ist es natürlich logischer, wie oben gezeigt. Wenn Sie jedoch weitere 100 solcher Funktionen schreiben müssen, ist es nicht sinnvoll, denselben Code so oft neu zu schreiben. Hier bieten sich Teilfunktionen an . Um sie zu verwenden, müssen wir zunächst einen Teil aus Functools importieren .from functools import partial
def multiply(x, y):
return x * y
doubleNum = partial(multiply, 2)
tripleNum = partial(multiply, 3)
Print(doubleNum(10))
Output: 20
Wie Sie dem Beispiel entnehmen können, werden die Standardwerte durch die Variablen auf der linken Seite ersetzt. Anstelle von x gibt es 2 und anstelle von y gibt es 10, wenn doubleNum (10) aufgerufen wird . In diesem Beispiel spielt die Reihenfolge keine Rolle, bei anderen Verwendungen kann sie jedoch eine Rolle spielen. Schauen wir uns ein Beispiel für diesen Fall an, um die Reihenfolge der Variablensubstitution zu verstehen.from functools import partial
def orderFunc(a,b,c,d):
return a*4 + b*3 + c*2 + d
result = partial(orderFunc,5,6,7)
print(result(8))
Output: 60
Vollständige Bestellung
Wir haben eine Funktion, orderFunc()in der wir amit 4, b3, c2 multiplizieren und dder Summe Werte hinzufügen .Wir haben eine erstellt Teilfunktion , dass Anrufe mit den Werten 5, 6 und 7. Nun werden die Werte 5, 6 und 7 werden die Variablen ersetzen , und entsprechend. Die Variable wird durch 8 ersetzt, da sie beim Aufruf übertragen wird . Das Ergebnis ist (4 * 5 + 6 * 3 + 7 * 2 + 8) = 60.result()orderFunc()abcdresult()In diesem Fall spielt die Reihenfolge der übertragenen Werte eine Rolle, denn wenn sich die Reihenfolge ändert, ändert sich auch das Ergebnis. Um Variablen zu korrigieren, können Sie Schlüsselwörter anstelle von Positionsargumenten verwenden. Schreiben wir den obigen Code mit Schlüsselwörtern als Argumenten neu.from functools import partial
def orderFunc(a,b,c,d):
return a*4 + b*3 + c*2 + d
result = partial(orderFunc,c=5,d=6)
print(result(8,4))
Output: 60
Hier haben wir den Wert 5 für die Variable cund 6 für die Variable festgelegt d. Anstelle von Variablen a, die bwerden Werte 8 und 4 erscheinen. Als Ergebnis erhalten wir (8 * 4 + 4 * 3 + 5 * 2 + 6) = 60. DiePartial - Funktion kann in einer Schleife und für wiederholte Berechnungen bestimmt werden. Schauen wir uns ein Beispiel an:from functools import partial
def add(x,y):
return x + y
add_partials = []
for i in range (1, 10):
function = partial(add, i)
add_partials.append(function)
print('Sum of {} and 2 is {}'.format(i,add_partials[i-1](2)))
Output:
Sum of 1 and 2 is 3
Sum of 2 and 2 is 4
Sum of 3 and 2 is 5
Sum of 4 and 2 is 6
Sum of 5 and 2 is 7
Sum of 6 and 2 is 8
Sum of 7 and 2 is 9
Sum of 8 and 2 is 10
Sum of 9 and 2 is 11
In diesem Beispiel werden wir einen bestimmten Wertebereich mit 2 zusammenfassen und die vorhandene Funktion wiederverwenden. Wir können partiell in der Schleife aufrufen und ihre Funktionalität verwenden, um die Summen zu berechnen. Wie Sie den Werten am Ausgang entnehmen können, haben wir einen Zyklus von 1 bis 10, und alle Werte in diesem Intervall werden mit der Teilfunktion , die die Additionsfunktion aufruft, zu 2 addiert .Metadaten
Obwohl Teilfunktionen unabhängig sind, behalten sie den Speicher (Metadaten) einer Funktion bei, die sie erweitern.from functools import partial
def add(x,y):
return x + y
result = partial(add,y=5)
print(result.func)
print(result.keywords)
Output:
<function add at 0x7f27b1aab620>
{'y': 5}
Der erste Aufruf von func übergibt den Namen der Funktion und ihre Adresse im Speicher, und der zweite Aufruf mit Schlüsselwörtern übergibt die Schlüsselwörter an die Funktion. Somit Teilfunktionen können selbst Dokumentation genannt werden , die Verwendung von Metadaten , dass sie von einer erweiterbaren Funktion erhalten. Wir können Funktionsmetadaten mit einem anderen Tool von functools aktualisieren . Ist ein Tool, mit dem Sie Feature-Metadaten aktualisieren können. Lassen Sie es uns anhand eines Beispiels herausfinden.update_wrapper partialUpdate_wrapperdef multiply(x, y):
"""Test string."""
return x * y
result = functools.partial(multiply, y=2)
try:
print ('Function Name:'+result.__name__)
except AttributeError:
print('Function Name: __no name__')
print ('Function Doc:'+result.__doc__)
print('Updating wrapper:')
functools.update_wrapper(result, multiply)
print ('Function Name:'+result.__name__)
print ('Function Doc:'+result.__doc__)
Output:
Function Name: __no name__
Function Doc:partial(func, *args, **keywords) - new function with partial application
of the given arguments and keywords.
Updating wrapper:
Function Name: multiply
Function Doc: Test string.
Wie Sie der Ausgabe entnehmen können, wurde der Funktion vor der Verwendung des Wrappers weder ein Name noch ein Dokument zugewiesen. Sobald wir die Funktionen name und doc mit aktualisiert haben update_wrapper, haben wir das entsprechende Ergebnis in der Ausgabe gesehen.Fazit
Mit functools können wir redundanten Code entfernen und die Möglichkeiten zur Wiederverwendung von Code in Python erhöhen. Je öfter Sie die Teilfunktion verwenden , desto mehr Anwendungsfälle werden geöffnet. Experimentieren und genießen!
Steig auf den Kurs.