Python >> Tutoriel Python >  >> Python

Comment enchaîner plusieurs appels de fonction en Python ?

Formulation du problème

Étant donné un certain nombre de fonctions f1, f2, …, fn . Comment enchaîner les appels de fonction pour que la sortie du i -ème fonction est utilisée comme entrée pour le (i+1) -ième fonction ?

f1()   – -> output f1() is input of f2()   – -> output f2() is input of f3() ...    – -> ... is input of fn()

Solution simple :chaînage

Voici la solution la plus simple et la plus Pythonique au problème de chaînage des appels de fonction :

def f1():
    return 'f1'


def f2(arg):
    return arg + ' f2'


def f3(arg):
    return arg + ' f3'


# Chain the outputs into the next functions
result = f3(f2(f1()))
print(result)
# f1 f2 f3
  • Vous définissez les arguments d'entrée de chaque fonction entre parenthèses.
  • Vous pouvez définir l'entrée sur n'importe quel nom et accéder à l'entrée dans le corps de la fonction à l'aide du nom de l'argument. Dans notre cas, nous utilisons le nom arg comme noms des arguments d'entrée.
  • Ensuite, vous utilisez la fonction externe f3(...) c'est la dernière fonction à exécuter. En entrée, vous utilisez le résultat de f2(...) . Comme entrée pour cette fonction, vous utilisez le résultat de f1() . De cette façon, vous pouvez enchaîner trois fonctions ou plus en utilisant le modèle f3(f2(f1())) .

Solution avancée :méta-fonction pythonique pour un nombre arbitraire de chaînes de fonctions

Si vous avez de nombreuses fonctions (plus de, disons, dix fonctions), la méthode montrée précédemment devient fastidieuse. Dans ce cas, je recommanderais d'utiliser une approche fonctionnelle pour le chaînage de fonctions. Je sais, c'est méta !

def chain(start, *funcs):
    res = start
    for func in funcs:
        res = func(res)
    return res

Le chain() La fonction prend une graine initiale appelée start. Il passe ensuite en revue toutes les fonctions passées en arguments et passe le résultat actuel en entrée de la fonction. Ensuite, il remplace le résultat actuel par la sortie de la fonction, enchaînant la sortie d'une fonction dans les arguments d'entrée de la fonction suivante.

Vous pouvez désormais enchaîner une fonction :

def increment(arg):
    return arg + 1


inc_1 = chain(0, increment)
print(inc_1)
# 1

Mais vous pouvez aussi enchaîner 5 fonctions :

inc_5 = chain(0, increment, increment, increment, increment, increment)
print(inc_5)
# 5

Ou même 100 fonctions :

inc_100 = chain(0, *[increment] * 100)
print(inc_100)
# 100

C'est la même chose que increment(increment(...increment(increment(0))...)) .

Et vous pouvez également passer différents types de fonctions :

chain(start, f1, f2, f3, ..., f100)

En supposant que vous avez défini ou importé des fonctions f1 à f100 dans votre code.

Humour de programmeur – Blockchain


Prochain article