Exemple de fonctions d'ordre supérieur (décorateurs) en Python

J'ai créé divers outils et scripts Web avec Scheme sur ma propre machine, mais ces jours-ci PaaS bon marché, hautes performances et hautes performances, SaaS ne doit pas prendre en charge Scheme, Python comme langage alternatif, Scheme Nous avons créé et organisé un exemple pour gérer les fonctions d'ordre supérieur, qui est l'une des fonctionnalités.

La fonction d'ordre supérieur est simplement une "fonction qui prend la fonction elle-même comme argument ou valeur de retour". Pour plus de détails, reportez-vous à "Structure et interprétation des programmes informatiques" "1.3 Formulation d'abstractions avec des procédures d'ordre supérieur".

Définition et utilisation des fonctions d'ordre supérieur

Bien que lambda puisse être utilisé en Python, il ne peut être traité que comme une seule expression, il semble donc qu'il soit courant d'écrire une fonction définie localement par def.

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"

Un exemple du code Scheme correspondant est le suivant. Confirmez l'exécution avec 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"

Décorateur

Sucre de syntaxe lors de l'utilisation de fonctions d'ordre supérieur. L'origine du mot est une sorte de modèle de conception. C'est une manière pratique d'écrire lorsque vous souhaitez définir un framework tel que Flask en tant que groupe de fonctions d'ordre supérieur et ajouter des fonctions aux fonctions définies par l'utilisateur qui effectuent le traitement d'origine.

decorators.py

# threetimes，threetimes_le message est d'ordre supérieur.Utiliser la définition py

@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"

Autres échantillons utilisant lambda etc.

Exemple dans article Wikipedia (fonction d'ordre supérieur) Quelques extraits.

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]