Was bedeutet das Sternchen * in Python?

Question

Hat * in Python eine besondere Bedeutung wie in C? Ich habe eine solche Funktion im Python Cookbook gesehen:

def get(self, *a, **kw)

Würden Sie mir das bitte erklären oder mir zeigen, wo ich eine Antwort finden kann (Google interpretiert das * als Platzhalterzeichen und daher kann ich keine zufriedenstellende Antwort finden).

Answer 1

Véase Funktionsdefinitionen in der Sprachreferenz.

Wenn das Formular *identifier ist vorhanden, wird er mit einem Tupel initialisiert initialisiert, das alle Parameter, standardmäßig mit dem leeren Tupel. Wenn das Formular **identifier ist vorhanden, wird es mit einem neuen Wörterbuch initialisiert, das jedes überschüssige Schlüsselwortargumente, standardmäßig wird ein neues leeres Wörterbuch.

Siehe auch Funktionsaufrufe .

Vorausgesetzt, man weiß, was Positions- und Schlüsselwortargumente sind, hier einige Beispiele:

Beispiel 1:

# Excess keyword argument (python 2) example:
def foo(a, b, c, **args):
    print "a = %s" % (a,)
    print "b = %s" % (b,)
    print "c = %s" % (c,)
    print args

foo(a="testa", d="excess", c="testc", b="testb", k="another_excess")

Wie Sie im obigen Beispiel sehen können, haben wir nur Parameter a, b, c in der Signatur des foo Funktion. Da d y k nicht vorhanden sind, werden sie in das args-Wörterbuch aufgenommen. Die Ausgabe des Programms ist:

a = testa
b = testb
c = testc
{'k': 'another_excess', 'd': 'excess'}

Beispiel 2:

# Excess positional argument (python 2) example:
def foo(a, b, c, *args):
    print "a = %s" % (a,)
    print "b = %s" % (b,)
    print "c = %s" % (c,)
    print args

foo("testa", "testb", "testc", "excess", "another_excess")

Da wir hier Positionsargumente testen, müssen die überschüssigen Argumente am Ende stehen, und *args packt sie in ein Tupel, so dass die Ausgabe dieses Programms lautet:

a = testa
b = testb
c = testc
('excess', 'another_excess')

Sie können auch ein Wörterbuch oder ein Tupel in Argumente einer Funktion entpacken:

def foo(a,b,c,**args):
    print "a=%s" % (a,)
    print "b=%s" % (b,)
    print "c=%s" % (c,)
    print "args=%s" % (args,)

argdict = dict(a="testa", b="testb", c="testc", excessarg="string")
foo(**argdict)

Drucke:

a=testa
b=testb
c=testc
args={'excessarg': 'string'}

Y

def foo(a,b,c,*args):
    print "a=%s" % (a,)
    print "b=%s" % (b,)
    print "c=%s" % (c,)
    print "args=%s" % (args,)

argtuple = ("testa","testb","testc","excess")
foo(*argtuple)

Drucke:

a=testa
b=testb
c=testc
args=('excess',)

Answer 2

Ich möchte nur eine Sache hinzufügen, die aus den anderen Antworten nicht klar hervorging (nur der Vollständigkeit halber).

Sie können beim Aufruf der Funktion auch die Sterne verwenden. Ein Beispiel: Sie haben einen Code wie diesen:

>>> def foo(*args):
...     print(args)
...
>>> l = [1,2,3,4,5]

Sie können die Liste l wie folgt an foo übergeben...

>>> foo(*l)
(1, 2, 3, 4, 5)

Das Gleiche können Sie für Wörterbücher tun...

>>> def foo(**argd):
...     print(argd)
...
>>> d = {'a' : 'b', 'c' : 'd'}
>>> foo(**d)
{'a': 'b', 'c': 'd'}

Answer 3

Alle obigen Antworten waren vollkommen klar und vollständig, aber nur fürs Protokoll möchte ich bestätigen, dass die Bedeutung von * und ** in Python absolut keine Ähnlichkeit mit der Bedeutung von ähnlich aussehenden Operatoren in C hat.

Sie werden Argument-Entpacker und Schlüsselwort-Argument-Entpacker genannt.

Answer 4

Ein einzelner Stern bedeutet, dass die Variable "a" ein Tupel von zusätzlichen Parametern ist, die der Funktion übergeben wurden. Der doppelte Stern bedeutet, dass die Variable 'kw' ein Wörterbuch mit zusätzlichen Parametern variabler Größe ist, die mit Schlüsselwörtern übergeben wurden.

Obwohl das tatsächliche Verhalten spezifiziert ist, kann es manchmal sehr unintuitiv sein. Das Schreiben einiger Beispielfunktionen und deren Aufruf mit verschiedenen Parametern kann Ihnen helfen, zu verstehen, was erlaubt ist und was die Ergebnisse sind.

def f0(a)
def f1(*a)
def f2(**a)
def f3(*a, **b)
etc...

Answer 5

Ich finde * nützlich, wenn ich eine Funktion schreibe, die eine andere Callback-Funktion als Parameter hat:

def some_function(parm1, parm2, callback, *callback_args):
    a = 1
    b = 2
    ...
    callback(a, b, *callback_args)
    ...

Auf diese Weise können Aufrufer beliebige zusätzliche Parameter übergeben, die an ihre Callback-Funktion weitergeleitet werden. Das Schöne daran ist, dass die Callback-Funktion normale Funktionsparameter verwenden kann. Das heißt, sie braucht die *-Syntax überhaupt nicht zu verwenden. Hier ist ein Beispiel:

def my_callback_function(a, b, x, y, z):
    ...

x = 5
y = 6
z = 7

some_function('parm1', 'parm2', my_callback_function, x, y, z)

Natürlich bieten Closures eine andere Möglichkeit, das Gleiche zu tun, ohne dass Sie x, y und z durch some_function() und in my_callback_function() übergeben müssen.