Was bedeutet der Sternoperator in einem Funktionsaufruf?

Was bedeutet der *Operator in Python, beispielsweise in Code wie zip(*x)oder f(**k)?

1. Wie wird es intern im Dolmetscher gehandhabt?
2. Beeinträchtigt es überhaupt die Leistung? Ist es schnell oder langsam?
3. Wann ist es nützlich und wann nicht?
4. Sollte es in einer Funktionsdeklaration oder in einem Aufruf verwendet werden?

Der einzelne Stern *entpackt die Sequenz / Sammlung in Positionsargumente, sodass Sie Folgendes tun können:

def sum(a, b):
    return a + b

values = (1, 2)

s = sum(*values)

Dadurch wird das Tupel entpackt, sodass es tatsächlich wie folgt ausgeführt wird:

s = sum(1, 2)

Der Doppelstern **macht dasselbe, nur unter Verwendung eines Wörterbuchs und damit benannter Argumente:

values = { 'a': 1, 'b': 2 }
s = sum(**values)

Sie können auch kombinieren:

def sum(a, b, c, d):
    return a + b + c + d

values1 = (1, 2)
values2 = { 'c': 10, 'd': 15 }
s = sum(*values1, **values2)

wird ausgeführt als:

s = sum(1, 2, c=10, d=15)

Siehe auch Abschnitt 4.7.4 - Entpacken von Argumentlisten der Python-Dokumentation.

Darüber hinaus können Sie zu verwendende Funktionen *xund **yArgumente definieren. Auf diese Weise kann eine Funktion eine beliebige Anzahl von Positions- und / oder benannten Argumenten akzeptieren, die in der Deklaration nicht speziell benannt sind.

Beispiel:

def sum(*values):
    s = 0
    for v in values:
        s = s + v
    return s

s = sum(1, 2, 3, 4, 5)

oder mit **:

def get_a(**values):
    return values['a']

s = get_a(a=1, b=2)      # returns 1

Auf diese Weise können Sie eine große Anzahl optionaler Parameter angeben, ohne sie deklarieren zu müssen.

Und wieder können Sie kombinieren:

def sum(*values, **options):
    s = 0
    for i in values:
        s = s + i
    if "neg" in options:
        if options["neg"]:
            s = -s
    return s

s = sum(1, 2, 3, 4, 5)            # returns 15
s = sum(1, 2, 3, 4, 5, neg=True)  # returns -15
s = sum(1, 2, 3, 4, 5, neg=False) # returns 15

Ein kleiner Punkt: Dies sind keine Operatoren. Operatoren werden in Ausdrücken verwendet, um neue Werte aus vorhandenen Werten zu erstellen (1 + 2 wird beispielsweise zu 3). Die Zeichen * und ** sind hier Teil der Syntax von Funktionsdeklarationen und -aufrufen.

Ich finde dies besonders nützlich, wenn Sie einen Funktionsaufruf "speichern" möchten.

Angenommen, ich habe einige Komponententests für eine Funktion 'add':

def add(a, b): return a + b
tests = { (1,4):5, (0, 0):0, (-1, 3):3 }
for test, result in tests.items():
   print 'test: adding', test, '==', result, '---', add(*test) == result

Es gibt keine andere Möglichkeit, add aufzurufen, als manuell etwas wie add (test [0], test [1]) auszuführen, was hässlich ist. Wenn es eine variable Anzahl von Variablen gibt, kann der Code mit all den if-Anweisungen, die Sie benötigen, ziemlich hässlich werden.

Ein weiterer nützlicher Ort ist das Definieren von Factory-Objekten (Objekte, die Objekte für Sie erstellen). Angenommen, Sie haben eine Klasse Factory, die Autoobjekte herstellt und zurückgibt. Sie können es so gestalten, dass myFactory.make_car ('rot', 'bmw', '335ix') ein Auto ('rot', 'bmw', '335ix') erstellt und es dann zurückgibt.

def make_car(*args):
   return Car(*args)

Dies ist auch nützlich, wenn Sie den Konstruktor einer Oberklasse aufrufen möchten.

Es wird als erweiterte Aufrufsyntax bezeichnet. Aus der Dokumentation :

Wenn der Syntax * -Ausdruck im Funktionsaufruf angezeigt wird, muss der Ausdruck zu einer Sequenz ausgewertet werden. Elemente aus dieser Sequenz werden so behandelt, als wären sie zusätzliche Positionsargumente. Wenn es Positionsargumente x1, ..., xN gibt und der Ausdruck eine Folge y1, ..., yM ergibt, entspricht dies einem Aufruf mit M + N Positionsargumenten x1, ..., xN, y1 ,. .., yM.

und:

Wenn der Syntaxausdruck ** im Funktionsaufruf angezeigt wird, muss der Ausdruck zu einer Zuordnung ausgewertet werden, deren Inhalt als zusätzliche Schlüsselwortargumente behandelt wird. Wenn ein Schlüsselwort sowohl im Ausdruck als auch als explizites Schlüsselwortargument vorkommt, wird eine TypeError-Ausnahme ausgelöst.

In einem Funktionsaufruf verwandelt der einzelne Stern eine Liste in separate Argumente (z. B. zip(*x)ist das gleiche wie zip(x1,x2,x3)wenn x=[x1,x2,x3]) und der doppelte Stern verwandelt ein Wörterbuch in separate Schlüsselwortargumente (z. B. f(**k)ist das gleiche wie f(x=my_x, y=my_y)wenn) k = {'x':my_x, 'y':my_y}.

In einer Funktionsdefinition ist es umgekehrt: Der einzelne Stern wandelt eine beliebige Anzahl von Argumenten in eine Liste um, und der Doppelstart verwandelt eine beliebige Anzahl von Schlüsselwortargumenten in ein Wörterbuch. ZB def foo(*x)bedeutet "foo nimmt eine beliebige Anzahl von Argumenten und sie sind über die Liste x zugänglich (dh wenn der Benutzer anruft foo(1,2,3), xwird sein [1,2,3])" und def bar(**k)bedeutet "bar nimmt eine beliebige Anzahl von Schlüsselwortargumenten und sie sind über das Wörterbuch k zugänglich (dh wenn der Benutzer anruft bar(x=42, y=23), kwird {'x': 42, 'y': 23}) ".