Analyse approfondie de Python--Fonction Currying

L'exemple de cet article décrit une analyse approfondie de la fonction Python--Currying. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

1. Définition :

1) Il s'agit de changer la fonction d'origine qui accepte deux paramètres en une nouvelle qui accepte un processus de fonction de paramètre. La nouvelle fonction renvoie une fonction avec le deuxième paramètre d'origine comme paramètre

2) Exemple : Currying de la fonction d'addition : La méthode consiste à convertir la fonction en fonction Currying par imbrication.

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

2. Application :

Condition requise :

Une fonction d'ajout Je souhaite améliorer sa fonction et pouvoir sortir le paramètre appelé et appelé. information. .

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

Nous ajoutons maintenant la fonction de sortie d'informations

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

Bien que la fonction d'ajout ci-dessus remplisse les exigences, elle présente les trois inconvénients suivants :

1. Imprimer déclaration Le degré de couplage est trop élevé.

2. La fonction d'addition appartient à la fonction commerciale, et la fonction de sortie d'informations peut appartenir au code de fonction non commerciale et ne doit pas être placée dans l'ajout de fonction commerciale.

Ensuite, nous apportons les améliorations suivantes :

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))

Les améliorations ci-dessus réalisent la séparation des fonctions métier, mais la transmission de paramètres dans l'appel de fonction fn est un problème. Nous voulons transmettre des paramètres de manière flexible, mais les paramètres sont dans la fonction interne. Comment utiliser le langage flexible Python pour résoudre ce problème ?

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)

Maintenant, nous pouvons saisir les paramètres de manière flexible

Quelques exemples plus spécifiques sont donnés ci-dessous :

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)

Trois, résumé :

Après avoir appris le Currying, les connaissances les plus importantes et essentielles en python nous attendront - Décorateur.

Recommandations associées :

currying de la fonction js

Currying dans les expressions fonctionnelles

Portée, currying des fonctions JavaScript

Curry

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!