Beispiel für Funktionen höherer Ordnung (Dekoratoren) in Python

Ich habe verschiedene Tools und Web-Skripte mit Scheme auf meinem eigenen Computer erstellt, aber heutzutage sollte billiges, leistungsstarkes und leistungsstarkes PaaS, SaaS Scheme, Python als alternative Sprache, Scheme nicht unterstützen Wir haben ein Beispiel für die Handhabung von Funktionen höherer Ordnung erstellt und organisiert, was eine der Funktionen ist.

Die Funktion höherer Ordnung ist einfach eine "Funktion, die die Funktion selbst als Argument oder Rückgabewert verwendet". Weitere Informationen finden Sie unter "Struktur und Interpretation von Computerprogrammen" 1.3 Formulieren von Abstraktionen mit Verfahren höherer Ordnung ".

Definition und Verwendung von Funktionen höherer Ordnung

Obwohl Lambda in Python verwendet werden kann, kann es nur als einzelner Ausdruck behandelt werden. Daher scheint es üblich zu sein, eine Funktion zu schreiben, die lokal durch def definiert ist.

higherorder.py

def threetimes(f):
    def retfunc(x, y):
        print(f(f(f(x, y), y), y))
    return (retfunc)

def f(x, y):
    return (2 * x + y)

threetimes(f)(10, 5)
# => f(f(f(x, y), y), y)
# => (2 * (2 * (2 * 10 + 5) + 5) + 5) => "115"

def threetimes_message(mes = ""):
    def _threetimes(f):
        def retfunc(x, y):
            print(mes, end="")
            print(f(f(f(x, y), y), y))
        return (retfunc)
    return (_threetimes)

threetimes_message("Result = ")(f)(10, 5)
# => "Result = 115"

threetimes_message()(f)(10, 5)
# => "115"

Ein Beispiel für den entsprechenden Schemacode lautet wie folgt. Bestätigen Sie die Ausführung mit Gauche.

higherorder.scm

(define threetimes
  (lambda (f)
    (lambda (x y)
      (print (f (f (f x y) y) y)))))

(define f (lambda (x y) (+ (* 2 x) y)))
((threetimes f) 10 5)
; => (f (f (f 10 5) 5) 5)
; => (+ (* 2 (+ (* 2 (+ (* 2 10) 5)) 5)) 5) => "115"

(define threetimes_message
  (lambda (f . mes)
    (lambda (x y)
      (if (not (null? mes)) (display (car mes)))
      (print (f (f (f x y) y) y)))))

((threetimes_message f "Result = ") 10 5)
; => "Result = 115"
((threetimes_message f) 10 5)
; => "115"

Dekorateur

Syntaxzucker bei Verwendung von Funktionen höherer Ordnung. Das Wort Ursprung ist eine Art Designmuster. Dies ist eine bequeme Methode zum Schreiben, wenn Sie ein Framework wie Flask als Gruppe von Funktionen höherer Ordnung definieren und den benutzerdefinierten Funktionen, die die ursprüngliche Verarbeitung ausführen, Funktionen hinzufügen möchten.

decorators.py

# threetimes，threetimes_Nachricht ist höherer Ordnung.Verwenden Sie die py-Definition

@threetimes
def f(x, y):
    return(2 * x + y)

f(10, 5) # => "115"

@threetimes_message(mes = "Result = ")
def f(x, y):
    return(2 * x + y)

f(10, 5) # => "Result = 115"

@threetimes_message()
def f(x, y):
    return (2 * x + y)

f(10, 5) # => "115"

Andere Proben mit Lambda usw.

Beispiel in Wikipedia-Artikel (Funktion höherer Ordnung) Einige Auszüge.

others.py

def args_10_5(f):
    def _args_10_5():
        f(10, 5)
    return (_args_10_5)

def f(x, y):
  print("x = ", x, ", y = ", y)

args_10_5(f)() # => "x =  10 , y =  5"

def f(x, y, z, w):
  return (4 * x + 3 * y + 2 * z + w)

f(2, 3, 4, 5) # => 30

def f(x):
    return (lambda y: lambda z: lambda w: 4 * x + 3 * y + 2 * z + w)

f(2)(3)(4)(5) # => 30

def unfold(pred, f, update, seed):
    if pred(seed):
        return ([])
    else:
        r = unfold(pred, f, update, update(seed))
        r.insert(0, f(seed))
        return (r)

unfold(lambda x: x > 10, lambda x: x * x, lambda x: x + 1, 1)
# => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]