The easiest approach would be first to write a composition of 2 functions:

def compose2(f, g):

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

And then use reduce to compose more functions:

def compose(*fs):

    return reduce(compose2, fs)

Or you can use some library, which already contains compose function.

def compose (*functions):

    def inner(arg):

        for f in reversed(functions):

            arg = f(arg)

        return arg

    return inner

Example:

>>> def square (x):

        return x ** 2

>>> def increment (x):

        return x + 1

>>> def half (x):

        return x / 2



>>> composed = compose(square, increment, half) # square(increment(half(x)))

>>> composed(5) # square(increment(half(5))) = square(increment(2.5)) = square(3.5) = 12,25

12.25

Recursive implementation

Here's a fairly elegant recursive implementation, which uses features of Python 3 for clarity:

def strict_compose(*funcs):

    *funcs, penultimate, last = funcs

    if funcs:

        penultimate = strict_compose(*funcs, penultimate)

    return lambda *args, **kwargs: penultimate(last(*args, **kwargs))

Python 2 compatible version:

def strict_compose2(*funcs):

    if len(funcs) > 2:

        penultimate = strict_compose2(*funcs[:-1])

    else:

        penultimate = funcs[-2]

    return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))

This is an earlier version which uses lazy evaluation of the recursion:

def lazy_recursive_compose(*funcs):

    def inner(*args, _funcs=funcs, **kwargs):

        if len(_funcs) > 1:

            return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])

        else:

            return _funcs[0](*args, **kwargs)

    return inner

Both would seem to make a new tuple and dict of arguments each recursive call.

Comparison of all suggestions:

Let's test some of these implementations and determine which is most performant, first some single argument functions (Thank you poke):

def square(x):

    return x ** 2



def increment(x):

    return x + 1



def half(x):

    return x / 2

Here's our implementations, I suspect my iterative version is the second most efficient (manual compose will naturally be fastest), but that may be in part due to it sidestepping the difficulty of passing any number of arguments or keyword arguments between functions - in most cases we'll only see the trivial one argument being passed.

from functools import reduce



def strict_recursive_compose(*funcs):

    *funcs, penultimate, last = funcs

    if funcs:

        penultimate = strict_recursive_compose(*funcs, penultimate)

    return lambda *args, **kwargs: penultimate(last(*args, **kwargs))



def strict_recursive_compose2(*funcs):

    if len(funcs) > 2:

        penultimate = strict_recursive_compose2(*funcs[:-1])

    else:

        penultimate = funcs[-2]

    return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))



def lazy_recursive_compose(*funcs):

    def inner(*args, _funcs=funcs, **kwargs):

        if len(_funcs) > 1:

            return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])

        else:

            return _funcs[0](*args, **kwargs)

    return inner



def iterative_compose(*functions):

    """my implementation, only accepts one argument."""

    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)

And to test these:

import timeit



def manual_compose(n):

    return square(increment(half(n)))



composes = (strict_recursive_compose, strict_recursive_compose2, 

            lazy_recursive_compose, iterative_compose, 

            reduce_compose1, reduce_compose2)



print('manual compose', min(timeit.repeat(lambda: manual_compose(5))), manual_compose(5))

for compose in composes:

    fn = compose(square, increment, half)

    result = min(timeit.repeat(lambda: fn(5)))

    print(compose.__name__, result, fn(5))

Results

And we get the following output (same magnitude and proportion in Python 2 and 3):

manual compose 0.4963762479601428 12.25

strict_recursive_compose 0.6564744340721518 12.25

strict_recursive_compose2 0.7216697579715401 12.25

lazy_recursive_compose 1.260614730999805 12.25

iterative_compose 0.614982972969301 12.25

reduce_compose1 0.6768529079854488 12.25

reduce_compose2 0.9890829260693863 12.25

And my expectations were confirmed: the fastest is of course, manual function composition followed by the iterative implementation. The lazy recursive version is much slower - likely since a new stack frame is created by each function call and a new tuple of functions is created for each function.

For a better and perhaps more realistic comparison, if you remove **kwargs and change *args to arg in the functions, the ones that used them will be more performant, and we can better compare apples to apples - here, aside from manual composition, reduce_compose1 wins followed by the strict_recursive_compose:

manual compose 0.443808660027571 12.25

strict_recursive_compose 0.5409777010791004 12.25

strict_recursive_compose2 0.5698030130006373 12.25

lazy_recursive_compose 1.0381018499610946 12.25

iterative_compose 0.619289995986037 12.25

reduce_compose1 0.49532539502251893 12.25

reduce_compose2 0.9633988010464236 12.25

Functions with just one arg:

def strict_recursive_compose(*funcs):

    *funcs, penultimate, last = funcs

    if funcs:

        penultimate = strict_recursive_compose(*funcs, penultimate)

    return lambda arg: penultimate(last(arg))



def strict_recursive_compose2(*funcs):

    if len(funcs) > 2:

        penultimate = strict_recursive_compose2(*funcs[:-1])

    else:

        penultimate = funcs[-2]

    return lambda arg: penultimate(funcs[-1](arg))



def lazy_recursive_compose(*funcs):

    def inner(arg, _funcs=funcs):

        if len(_funcs) > 1:

            return inner(_funcs[-1](arg), _funcs=_funcs[:-1])

        else:

            return _funcs[0](arg)

    return inner



def iterative_compose(*functions):

    """my implementation, only accepts one argument."""

    def inner(arg):

        for f in reversed(functions):

            arg = f(arg)

        return arg

    return inner



def _compose2(f, g):

    return lambda arg: f(g(arg))



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)

One liner:

compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F)

Example usage:

f1 = lambda x: x+3

f2 = lambda x: x*2

f3 = lambda x: x-1

g = compose(f1, f2, f3)

assert(g(7) == 15)

You can also create an array of functions and use reduce:

def f1(x): return x+1

def f2(x): return x+2

def f3(x): return x+3



x = 5



# Will print f3(f2(f1(x)))

print reduce(lambda acc, x: x(acc), [f1, f2, f3], x)



# As a function:

def compose(*funcs):

    return lambda x: reduce(lambda acc, f: f(acc), funcs, x)



f = compose(f1, f2, f3)

Poke's answer is good, but you can also use the functional package which comes with a compose method.

The most reliable implementation I have found is in the 3rd party library toolz. The compose function from this library also deals with docstring for the composition of functions.

The source code is freely available. Below is a simple example of usage.

from toolz import compose



def f(x):

    return x+1



def g(x):

    return x*2



def h(x):

    return x+3



res = compose(f, g, h)(5)  # 17

pip install funcoperators is another library to implement it that allows infix notation:

from funcoperators import compose



# display = lambda x: hex(ord(list(x)))

display = hex *compose* ord *compose* list



# also works as a function

display = compose(hex, ord, list)

pip install funcoperators https://pypi.org/project/funcoperators/

Disclaimer: I'm the creator of the module

This is my 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

An example of how it's used

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