Composer des fonctions en python

L'approche la plus simple serait le premier à écrire une composition de 2 fonctions:

def compose2(f, g):
    return lambda *a, **kw: f(g(*a, **kw))

Et ensuite utiliser reduce pour composer plus de fonctions:

def compose(*fs):
    return reduce(compose2, fs)

Ou vous pouvez utiliser certains de la bibliothèquequi contient déjà composer fonction.

Récursive de la mise en œuvre de

Voici un appel récursif à la mise en œuvre, je l'ai pas encore vu:

def compose(*funcs):
    def inner(data, funcs=funcs):
        return inner(funcs[-1](data), funcs[:-1]) if funcs else data
    return inner

Je ne vous attendez pas à être très performant, même si, comme il fait à nouveau un n-uplet d'arguments à chaque appel récursif.

Comparaison de toutes les suggestions:

Nous allons tester certains de ces implémentations et de déterminer lequel est le plus performant, tout d'abord, quelques seul argument des fonctions (Merci poke):

def square (x):
    return x ** 2

def increment (x):
    return x + 1

def half (x):
    return x / 2

Voici nos implémentations, je soupçonne que le itératif version est la deuxième plus efficace (manuel de composer sera naturellement plus rapide).

from functools import reduce

def recursive_compose(*funcs):
    def inner(data, funcs=funcs):
        return inner(funcs[-1](data), funcs[:-1]) if funcs else data
    return inner

def iterative_compose(*functions):
    def inner(arg):
        for f in reversed(functions):
            arg = f(arg)
        return arg
    return inner

def _compose2(f, g):
    return lambda *a, **kw: f(g(*a, **kw))

def reduce_compose1(*fs):
    return reduce(_compose2, fs)

def reduce_compose2(*funcs):
    """bug fixed - added reversed()"""
    return lambda x: reduce(lambda acc, f: f(acc), reversed(funcs), x)

Et de les tester:

import timeit
composes = (recursive_compose, iterative_compose, 
            reduce_compose1, reduce_compose2)

def manual():
    return square(increment(half(5)))

print('manual compose', min(timeit.repeat(manual)), manual())

for compose in composes:
    fn = lambda: compose(square, increment, half)(5)
    result = min(timeit.repeat(fn))
    print(compose.__name__, result, fn())

Résultats

Et nous obtenons le résultat suivant (même ampleur et de la proportion en Python 2 et 3):

manual compose 0.607658714056015 12.25
recursive_compose 1.929560380987823 12.25
iterative_compose 1.3319460819475353 12.25
reduce_compose1 2.0850532418116927 12.25
reduce_compose2 1.5899418010376394 12.25

Et mes attentes ont été confirmés: le plus rapide est bien sûr, le manuel, la fonction de composition suivie par l'itératif de mise en œuvre. Une version récursive est beaucoup plus lente, probablement depuis une nouvelle trame de pile est créé par chaque appel de fonction et un nouveau tuple de fonctions est créé pour chaque fonction.

Poke la réponse est bonne, mais vous pouvez également utiliser le functional paquet est livré avec un composer de la méthode.

C'est ma version

def compose(*fargs):
    def inner(arg):
        if not arg:
            raise ValueError("Invalid argument")
        if not all([callable(f) for f in fargs]):
            raise TypeError("Function is not callable")
        return reduce(lambda arg, func: func(arg), fargs, arg)
    return inner

Un exemple de la façon dont il est utilisé

def calcMean(iterable):
    return sum(iterable) / len(iterable)


def formatMean(mean):
    return round(float(mean), 2)


def adder(val, value):
    return val + value


def isEven(val):
    return val % 2 == 0

if __name__ == '__main__':
    # Ex1

    rand_range = [random.randint(0, 10000) for x in range(0, 10000)]

    isRandIntEven = compose(calcMean, formatMean,
                            partial(adder, value=0), math.floor.__call__, isEven)

    print(isRandIntEven(rand_range))