Rufen Sie eine Funktion mit Argumentliste in Python auf

Ich versuche, eine Funktion in einer anderen Funktion in Python aufzurufen, finde aber nicht die richtige Syntax. Was ich tun möchte, ist ungefähr so:

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

def func1(x):
    print(x)

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

wrapper(func1, [x])
wrapper(func2, [x, y, z])

In diesem Fall funktioniert der erste Anruf und der zweite nicht. Was ich ändern möchte, ist die Wrapper-Funktion und nicht die aufgerufenen Funktionen.

Um die anderen Antworten ein wenig zu erweitern:

In der Schlange:

def wrapper(func, *args):

Das * neben argsbedeutet "Nehmen Sie den Rest der angegebenen Parameter und fügen Sie sie in eine Liste mit dem Namen args" ein.

In der Schlange:

    func(*args)

Das * neben argshier bedeutet "Nehmen Sie diese Liste mit dem Namen args und" entpacken "Sie sie in den Rest der Parameter.

Sie können also Folgendes tun:

def wrapper1(func, *args): # with star
    func(*args)

def wrapper2(func, args): # without star
    func(*args)

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

wrapper1(func2, 1, 2, 3)
wrapper2(func2, [1, 2, 3])

In wrapper2wird die Liste explizit übergeben, aber in beiden Wrappern argsist die Liste enthalten [1,2,3].

Der einfachste Weg, eine Funktion zu verpacken

    func(*args, **kwargs)

... besteht darin, manuell einen Wrapper zu schreiben, der func () in sich selbst aufruft :

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

In Python ist die Funktion ein Objekt, sodass Sie den Namen als Argument einer anderen Funktion übergeben und zurückgeben können. Sie können auch einen Wrapper-Generator für jede Funktion anyFunc () schreiben :

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

Beachten Sie auch, dass Sie in Python, wenn Sie nicht alle Argumente einer Funktion kennen oder nicht benennen möchten, auf ein Tupel von Argumenten verweisen können, das durch seinen Namen gekennzeichnet ist, gefolgt von einem Sternchen in den Klammern danach der Funktionsname:

    *args

Sie können beispielsweise eine Funktion definieren, die eine beliebige Anzahl von Argumenten akzeptiert:

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

Python bietet noch weitere Manipulationen an Funktionsargumenten. Sie können einer Funktion erlauben, Schlüsselwortargumente anzunehmen. Innerhalb des Funktionskörpers werden die Schlüsselwortargumente in einem Wörterbuch gespeichert. In den Klammern nach dem Funktionsnamen wird dieses Wörterbuch durch zwei Sternchen gefolgt vom Namen des Wörterbuchs gekennzeichnet:

    **kwargs

Ein ähnliches Beispiel, das das Schlüsselwortargument-Wörterbuch druckt:

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

Sie können die Syntax * args und ** kwargs für Argumente variabler Länge verwenden.

Was bedeuten * args und ** kwargs?

Und aus dem offiziellen Python-Tutorial

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

Die wörtliche Antwort auf Ihre Frage (um genau das zu tun, was Sie gefragt haben, ändern Sie nur den Wrapper, nicht die Funktionen oder die Funktionsaufrufe) besteht einfach darin, die Zeile zu ändern

func(args)

lesen

func(*args)

Dies weist Python an, die angegebene Liste (in diesem Fall args) zu übernehmen und ihren Inhalt als Positionsargumente an die Funktion zu übergeben.

Dieser Trick funktioniert auf beiden "Seiten" des Funktionsaufrufs, sodass eine Funktion wie folgt definiert ist:

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

wäre in der Lage, so viele Positionsargumente zu akzeptieren, wie Sie darauf werfen, und sie alle in eine Liste mit dem Namen zu setzen args.

Ich hoffe, das hilft, die Dinge ein wenig zu klären. Beachten Sie, dass dies alles auch mit dicts / keyword-Argumenten möglich ist, indem Sie **anstelle von verwenden *.

Sie müssen Argumente zum Entpacken verwenden.

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)

Eine kleine Ergänzung zu früheren Antworten, da ich keine Lösung für ein Problem finden konnte, die es nicht wert ist, eine neue Frage zu stellen, sondern mich hierher geführt hat.

Hier ist ein kleiner Code - Schnipsel, die kombiniert lists, zip()und *argseine Umhüllung zu schaffen , die mit einer unbekannten Menge von Funktionen mit einer unbekannten Menge von Argumenten umgehen kann.

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)

Beachten Sie, dass zip()dies keine Sicherheitsüberprüfung für Listen mit ungleicher Länge bietet. Siehe Zip-Iteratoren, die für die gleiche Länge in Python angeben .