it-swarm.com.de

Was bedeutet Sternchen * in Python?

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

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

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

Vielen Dank.

287
Martin08

Siehe Funktionsdefinitionen in der Sprachreferenz.

Wenn das Formular *identifier vorhanden ist, wird es mit einem Tupel initialisiert, das alle überzähligen Positionsparameter empfängt, wobei standardmäßig das leere Tupel verwendet wird. Wenn das Formular **identifier vorhanden ist, wird es mit einem neuen Wörterbuch initialisiert, das alle überzähligen Schlüsselwortargumente empfängt. Standardmäßig wird ein neues leeres Wörterbuch verwendet.

Siehe auch Funktionsaufrufe .

Angenommen, man weiß, was Positions- und Schlüsselwortargumente sind, dann 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 der Funktion foo. Da d und 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 überzähligen am Ende stehen, und *args packt sie in ein Tupel, die Ausgabe dieses Programms ist also:

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

Sie können ein Wörterbuch oder einen Tupel auch 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'}

Und

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',)
245
S.Lott

Ich habe nur eine Sache hinzuzufügen, die aus den anderen Antworten nicht klar hervorgeht (der Vollständigkeit halber).

Sie können beim Aufrufen der Funktion auch die Sterne verwenden. Angenommen, Sie haben folgenden Code:

>>> 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)

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

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

Alle obigen Antworten waren vollkommen klar und vollständig, aber nur zur Veranschaulichung möchte ich bestätigen, dass die Bedeutung von * und ** in python) absolut keine Ähnlichkeit mit der Bedeutung von ähnlich hat aussehende Operatoren in C.

Sie werden als Argumententpackungs- und Schlüsselwortargumententpackungsoperatoren bezeichnet.

70
Salim Fadhley

Ein einzelner Stern bedeutet, dass die Variable 'a' ein Tupel zusätzlicher Parameter ist, die an die Funktion übergeben wurden. Der Doppelstern bedeutet, dass die Variable 'kw' ein Wörterbuch mit variabler Größe und zusätzlichen Parametern ist, die mit Schlüsselwörtern versehen wurden.

Obwohl das tatsächliche Verhalten nicht genau festgelegt ist, kann es dennoch manchmal sehr uninteressant sein. Wenn Sie einige Beispielfunktionen schreiben und sie mit verschiedenen Parameterstilen aufrufen, können Sie möglicherweise besser verstehen, was zulässig ist und welche Ergebnisse erzielt werden.

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

Ich finde * nützlich, wenn ich eine Funktion schreibe, die eine andere Rückruffunktion als Parameter verwendet:

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

Auf diese Weise können Anrufer beliebige zusätzliche Parameter übergeben, die an ihre Rückruffunktion übergeben werden. Das Schöne ist, dass die Rückruffunktion normale Funktionsparameter verwenden kann. Das heißt, es muss überhaupt nicht die Syntax * verwendet werden. 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.

27
Clint Miller