Was bewirken ** (Doppelstern/Ostern) und * (Stern/Ostern) bei Parametern?

Question

Was tun *args y **kwargs bedeuten?

def foo(x, y, *args):
def bar(x, y, **kwargs):

Answer 1

* bedeutet, variable Argumente als Tupel zu erhalten

** bedeutet, variable Argumente als Wörterbuch zu erhalten

Wird wie folgt verwendet:

1) einzeln *

def foo(*args):
    for arg in args:
        print(arg)

foo("two", 3)

Ausgabe:

two
3

2) Jetzt ``**

def bar(**kwargs):
    for key in kwargs:
        print(key, kwargs[key])

bar(dic1="two", dic2=3)

Ausgabe:

dic1 two
dic2 3

Answer 2

In Python 3.5 können Sie diese Syntax auch in list , dict , tuple y set Anzeigen (manchmal auch Literale genannt). Siehe PEP 488: Zusätzliche Verallgemeinerungen zum Auspacken .

>>> (0, *range(1, 4), 5, *range(6, 8))
(0, 1, 2, 3, 5, 6, 7)
>>> [0, *range(1, 4), 5, *range(6, 8)]
[0, 1, 2, 3, 5, 6, 7]
>>> {0, *range(1, 4), 5, *range(6, 8)}
{0, 1, 2, 3, 5, 6, 7}
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> e = {'six': 6, 'seven': 7}
>>> {'zero': 0, **d, 'five': 5, **e}
{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}

Außerdem können mehrere Iterables mit einem einzigen Funktionsaufruf entpackt werden.

>>> range(*[1, 10], *[2])
range(1, 10, 2)

(Dank an mgilson für den PEP-Link.)

Answer 3

TL;DR

Sie packt die an die Funktion übergebenen Argumente in list y dict jeweils innerhalb des Funktionskörpers. Wenn Sie eine Funktionssignatur wie diese definieren:

def func(*args, **kwds):
    # do stuff

Es kann mit einer beliebigen Anzahl von Argumenten und Schlüsselwortargumenten aufgerufen werden. Die Nicht-Schlüsselwort-Argumente werden in eine Liste namens args innerhalb des Funktionskörpers und die Schlüsselwortargumente werden in ein Diktat namens kwds innerhalb des Funktionskörpers.

func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])

nun innerhalb des Funktionskörpers, wenn die Funktion aufgerufen wird, gibt es zwei lokale Variablen, args die eine Liste mit dem Wert ["this", "is a list of", "non-keyword", "arguments"] y kwds die eine dict Wert habend {"keyword" : "ligma", "options" : [1,2,3]}

---

Dies funktioniert auch in umgekehrter Richtung, d.h. von der Seite des Aufrufers:

def f(a, b, c, d=1, e=10):
    # do stuff

mit dem Sie es aufrufen können, indem Sie Iterables oder Mappings auspacken, die Sie im aufrufenden Bereich haben:

iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)

Answer 4

Ich möchte ein Beispiel anführen, das andere nicht erwähnt haben

* kann auch eine Datei auspacken Generator

Ein Beispiel aus dem Python3-Dokument

x = [1, 2, 3]
y = [4, 5, 6]

unzip_x, unzip_y = zip(*zip(x, y))

unzip_x wird [1, 2, 3] sein, unzip_y wird [4, 5, 6] sein

Die Funktion zip() empfängt mehrere iretable-Args und gibt einen Generator zurück.

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))

Answer 5

Aufbauend auf nickd's Antwort ...

def foo(param1, *param2):
    print(param1)
    print(param2)

def bar(param1, **param2):
    print(param1)
    print(param2)

def three_params(param1, *param2, **param3):
    print(param1)
    print(param2)
    print(param3)

foo(1, 2, 3, 4, 5)
print("\n")
bar(1, a=2, b=3)
print("\n")
three_params(1, 2, 3, 4, s=5)

Ausgabe:

1
(2, 3, 4, 5)

1
{'a': 2, 'b': 3}

1
(2, 3, 4)
{'s': 5}

Grundsätzlich kann eine beliebige Anzahl von Positionsbezogene Argumente kann *args und beliebige genannte Argumente (oder kwargs alias Schlüsselwortargumente) können **kwargs verwenden.