Wywołanie funkcji z listą argumentów w Pythonie

Najprostszy sposób zawijania funkcji

    func(*args, **kwargs)

... jest ręczne napisanie wrappera wywołującego func () wewnątrz siebie:

    def wrapper(*args, **kwargs):
        # do something before
        try:
            return func(*a, **kwargs)
        finally:
            # do something after

W Pythonie funkcja jest obiektem, więc możesz przekazać jej nazwę jako argument innej funkcji i zwrócić ją. Możesz również napisać generator wrappera dla dowolnej funkcji anyFunc():

    def wrapperGenerator(anyFunc, *args, **kwargs):
        def wrapper(*args, **kwargs):
            try:
                # do something before
                return anyFunc(*args, **kwargs)
            finally:
                #do something after
        return wrapper

Należy również pamiętać, że w Pythonie, gdy nie znasz lub nie chcesz wymienić wszystkich argumentów funkcji, możesz odwołać się do krotka argumentów oznaczana nazwą, poprzedzona gwiazdką w nawiasach po nazwie funkcji:

    *args

Na przykład można zdefiniować funkcję, która przyjmowałaby dowolną liczbę argumentów:

    def testFunc(*args):
        print args    # prints the tuple of arguments

Python umożliwia jeszcze dalszą manipulację argumentami funkcji. Możesz zezwolić funkcji na przyjmowanie argumentów słów kluczowych. W ciele funkcji argumenty słów kluczowych są przechowywane w słowniku. W nawiasach po nazwie funkcji słownik ten jest oznaczony po dwóch gwiazdkach, po których następuje Nazwa słownika:

    **kwargs

Podobny przykład wypisujący słowo kluczowe arguments dictionary:

    def testFunc(**kwargs):
        print kwargs    # prints the dictionary of keyword arguments

Możesz używać składni *args i **kwargs dla argumentów o zmiennej długości.

Co oznaczają "args" i "kwargs"?

I z oficjalnego samouczka Pythona

Http://docs.python.org/dev/tutorial/controlflow.html#more-on-defining-functions

Musisz użyć argumentów rozpakowujących..

def wrapper(func, *args):
    func(*args)

def func1(x):
    print(x)

def func2(x, y, z):
    print x+y+z

wrapper(func1, 1)
wrapper(func2, 1, 2, 3)

Dosłowna odpowiedź na twoje pytanie (aby zrobić dokładnie to, o co prosiłeś, zmieniając tylko wrapper, a nie funkcje lub wywołania funkcji) to po prostu zmienić linię

func(args)

Do przeczytania

func(*args)

To mówi Pythonowi, aby wziął podaną listę (w tym przypadku args) i przekazał jej zawartość funkcji jako argumenty pozycyjne.

Ten trik działa po obu "stronach" wywołania funkcji, więc funkcja zdefiniowana tak:

def func2(*args):
    return sum(args)

Byłby w stanie przyjąć jak najwięcej argumenty pozycyjne, gdy je rzucasz, i umieść je wszystkie na liście o nazwie args.

Mały dodatek do poprzednich odpowiedzi, ponieważ nie mogłem znaleźć rozwiązania problemu, co nie jest warte otwierania nowego pytania, ale doprowadziło mnie tutaj.

Oto mały fragment kodu, który łączy lists, zip() i *args, aby zapewnić wrapper, który może radzić sobie z nieznaną ilością funkcji z nieznaną ilością argumentów.

def f1(var1, var2, var3):
    print(var1+var2+var3)

def f2(var1, var2):
    print(var1*var2)

def f3():
    print('f3, empty')

def wrapper(a,b, func_list, arg_list):
    print(a)
    for f,var in zip(func_list,arg_list):
        f(*var)
    print(b)

f_list = [f1, f2, f3]
a_list = [[1,2,3], [4,5], []]

wrapper('begin', 'end', f_list, a_list)

Należy pamiętać, że zip() nie zapewnia kontroli bezpieczeństwa dla list o nierównej długości, patrz Iteratory zip twierdzące o równej długości w python .