Defining pipelines of functions when passing a main argument across multiple functions Discovering sk-learn pipelines (https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) made me wonder why weren't I using the same idea for any set of functions applied to a single main argument.
Based on this idea I developed the following code (Using kwargs treatment from https://stackoverflow.com/a/58543357):
import inspect
def create_sequential_pipe(func_list):
    &quot;&quot;&quot;
    Create a pipeline for a series of functions to be applied to a single main argument

    Args:
        func_list: List of functions
    &quot;&quot;&quot;

    def sequential_pipe(main_arg, **kwargs):

        for func in sequential_pipe._func_list:

            func_args = [k for k, v in inspect.signature(func).parameters.items()]
            func_dict = {k: kwargs.pop(k) for k in dict(kwargs) if k in func_args}
            main_arg = func(main_arg, **func_dict)

        return main_arg

    sequential_pipe._func_list = func_list

    return sequential_pipe


def example_func_1(n, power=1):
    return n ** power


def example_func_2(n, sum=0):
    return n + sum


def example_func_3(n, divide=1):
    return n / divide


if __name__ == &quot;__main__&quot;:

    example_pipe= create_sequential_pipe([example_func_1, example_func_2, example_func_3])

    out = example_pipe(2)
    print(out)  # 2.0

    out = example_pipe(2, power=2, sum=1, divide=5)
    print(out)  # 1.0

I feel I could get used to its use, but I couldn't find something similar already implemented in Python, so I feel there must be a downside I am not seeing.
I could just create a wrapper function for the pipeline of functions, but I'm not sure it would be as simple.
Is there something similar commonly used in other languages? Do you think it's obfuscates the code? Are there clear downsides to using this?
Without being familiar in use of sklearn, there are still some Python fundamentals that can be improved:
Superfluous comprehension
func_args = [k for k, v in inspect.signature(func).parameters.items()]

can probably be
func_args = inspect.signature(func).parameters.keys()

assuming that parameters has the interface of a regular dictionary. Also, since you're only using it to test membership, wrap it in a call to set().
Set intersection
If you do the above and make func_args a set, then this:
for k in dict(kwargs) if k in func_args

can be replaced by set(kwargs.keys()) &amp; func_args.
Non-repeatable read
There's a potential issue with your use of pop(). This modifies your kwargs in a loop. Are you sure that you want a given kwarg to only apply to one function in your pipe, and not all of them?
Real tests
Convert this:
example_pipe= create_sequential_pipe([example_func_1, example_func_2, example_func_3])

out = example_pipe(2)
print(out)  # 2.0

out = example_pipe(2, power=2, sum=1, divide=5)
print(out)  # 1.0

into an actual unit test - you're already most of the way there, so you might as well.
Variadic function
create_sequential_pipe(func_list):

is a good candidate for being turned into a variadic function, i.e. accepting *func_list. This will make invocation simpler in some cases, including the one you showed at the bottom - there will be no need for an inner list literal.