Implement clojure-a-like comp() function in python3
Your approach has one serious drawbacks: it creates N-1 new bound function instances on every invocation of the returned function with an argument length of N if big-O performance guarantees are relevant to you. To avoid this you can either use a loop or the reduce operation, both of which only create a fixed number of function instances (that doesn't depend on the number of functions to chain).

Additionally I believe that both variants are easier to understand than the code in your question because it doesn't rely on recursion.

Loop

def comp_loop(*fns):
    def comped(*x):
        for fn in reversed(fns):
            x = fn(*x)
        return x

    if len(fns) == 0:
        return lambda *x: x
    if len(fns) == 1:
        return fns[0]
    return comped


Reduce

from functools import reduce

def comp_reduce(*fns):
    if len(fns) == 0:
        return lambda *x: x
    if len(fns) == 1:
        return fns[0]
    return lambda *x: reduce(lambda accum, fn: fn(*accum), reversed(fns), x)