Eingehende Analyse der Python-Currying-Funktion

Das Beispiel in diesem Artikel beschreibt eine eingehende Analyse der Python--Currying-Funktion. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

1. Definition:

1) Es bezieht sich auf die Änderung der ursprünglichen Funktion, die zwei Parameter akzeptiert, in eine neue das akzeptiert einen Parameterfunktionsprozess. Die neue Funktion gibt eine Funktion mit dem ursprünglichen zweiten Parameter als Parameter zurück

2) Beispiel: Currying der Additionsfunktion: Die Methode besteht darin, die Funktion durch Verschachtelung in eine Currying-Funktion umzuwandeln.

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

2. Anwendung:

Anforderung:

Eine Additionsfunktion möchte ich in ihrer Funktion erweitern und den aufgerufenen und aufgerufenen Parameter ausgeben können Information. .

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

Jetzt fügen wir die Informationsausgabefunktion hinzu

def add(x,y):
    print('call add,x + y')  #log output to the console
    return x + y

Obwohl die obige Zusatzfunktion die Anforderungen erfüllt, weist sie die folgenden drei Mängel auf:

1. Drucken Anweisung Der Kopplungsgrad ist zu hoch.

2. Die Zusatzfunktion gehört zur Geschäftsfunktion, und die Funktion zum Ausgeben von Informationen kann zum Nicht-Geschäftsfunktionscode gehören und sollte nicht in den Geschäftsfunktionszusatz eingefügt werden.

Dann nehmen wir die folgenden Verbesserungen vor:

def add(x,y):
    return x + y
def logger(fn):
    print('begin')  #enhanced output
    x = fn(4,5)
    print('end')    #enhanced features
    return x
print(logger(add))

Die oben genannten Verbesserungen erreichen die Trennung von Geschäftsfunktionen, aber die Übergabe von Parametern im fn-Funktionsaufruf ist ein Problem. Wir möchten Parameter flexibel übergeben, aber die Parameter befinden sich in der internen Funktion. Wie kann dieses Problem mit der flexiblen Sprache Python gelöst werden?

def add(x,y):
    return x + y
def logger(fn):
    def _logger(*args,**kwargs):
        print('begin')
        c = fn(*args,**kwargs)
        print('end')
        return c
    return _logger
logger(add)(2,3)

Jetzt können wir Parameter flexibel eingeben

Ein paar weitere spezifische Beispiele sind unten aufgeführt:

def ad1(m,n,*,l=909):
    return m + n + l
def loger(fn,*args,**kwargs):
    print('What\'s the matter?')
    ret = fn(*args,**kwargs)
    return ret
print(loger(ad1,2,3,l=4))   #Can you currying them?

def add(x,y,*,z=9):
    return x + y + z
def logger(fn,*args,**kwargs):
    print('This is a stupid function')
    ret = fn(*args,**kwargs)  #after collections it needs to be deconstructed
    return ret
print(logger(add,2,4,z=17))

def ad1(m,n,*,l=909):
    return m + n + l
def loger(fn):
    def _loger(*args,**kwargs):   #append a function as wrapper
        print('What\'s the matter?')    
        ret = fn(*args,**kwargs)   #the function which is be wrapped and transfer args and kwargs
        return ret
    return _loger
#print(loger(ad1)(2,3,l=4))  also okay
t = loger(ad1)  #defind the function loger
r = t(2,3,l=4)  # income parameters and transfer it
print(r)

Drei, Zusammenfassung:

Nachdem wir Currying gelernt haben, erwarten uns die wichtigsten und wesentlichsten Kenntnisse in Python – Decorator.

Verwandte Empfehlungen:

JS-Funktion Currying

Currying in funktionalen Ausdrücken

Umfang, Currying von JavaScript-Funktionen

Curryieren

Das obige ist der detaillierte Inhalt vonEingehende Analyse der Python-Currying-Funktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!