python dict - * Argumente und ** Kwargs?




6 Answers

Die Syntax ist das * und ** . Die Namen *args und **kwargs sind nur durch Konvention, aber es gibt keine harte Anforderung, sie zu verwenden.

Sie würden *args Argumente verwenden, wenn Sie nicht sicher sind, wie viele Argumente an Ihre Funktion übergeben werden können, dh Sie können eine beliebige Anzahl von Argumenten an Ihre Funktion übergeben. Beispielsweise:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print( '{0}. {1}'.format(count, thing))
...
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

In ähnlicher **kwargs können Sie mit **kwargs benannte Argumente behandeln, die Sie nicht im Voraus definiert haben:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print( '{0} = {1}'.format(name, value))
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

Sie können diese auch zusammen mit benannten Argumenten verwenden. Die expliziten Argumente erhalten zuerst Werte und dann wird alles andere an *args und **kwargs . Die benannten Argumente stehen in der Liste an erster Stelle. Beispielsweise:

def table_things(titlestring, **kwargs)

Sie können auch beide in der gleichen Funktionsdefinition verwenden, aber *args müssen vor **kwargs .

Sie können beim Aufrufen einer Funktion auch die Syntax * und ** verwenden. Beispielsweise:

>>> def print_three_things(a, b, c):
...     print( 'a = {0}, b = {1}, c = {2}'.format(a,b,c))
...
>>> mylist = ['aardvark', 'baboon', 'cat']
>>> print_three_things(*mylist)
a = aardvark, b = baboon, c = cat

Wie Sie in diesem Fall sehen können, nimmt es die Liste (oder das Tupel) der Elemente und entpackt sie. Dadurch werden sie mit den Argumenten in der Funktion abgeglichen. Natürlich könnten Sie sowohl in der Funktionsdefinition als auch im Funktionsaufruf ein * haben.

get work

Diese Frage hat hier bereits eine Antwort:

Also habe ich Schwierigkeiten mit dem Konzept von *args und **kwargs .

Bisher habe ich gelernt, dass:

  • *args = Liste der Argumente - als Positionsargumente
  • **kwargs = Dictionary - deren Schlüssel werden zu separaten Schlüsselwortargumenten und die Werte werden zu Werten dieser Argumente.

Ich verstehe nicht, für welche Programmieraufgabe das hilfreich wäre.

Könnte sein:

Ich denke, Listen und Wörterbücher als Argumente einer Funktion und gleichzeitig als Platzhalter einzugeben, damit ich jedes Argument bestehen kann?

Gibt es ein einfaches Beispiel, um zu erklären, wie *args und **kwargs verwendet werden?

Auch das Tutorial fand ich nur mit dem "*" und einem Variablennamen.

Sind *args und **kwargs nur Platzhalter oder verwendest du genau *args und **kwargs im Code?




Hier ist ein Beispiel, das 3 verschiedene Arten von Parametern verwendet.

def func(required_arg, *args, **kwargs):
    # required_arg is a positional-only parameter.
    print required_arg

    # args is a tuple of positional arguments,
    # because the parameter name has * prepended.
    if args: # If args is not empty.
        print args

    # kwargs is a dictionary of keyword arguments,
    # because the parameter name has ** prepended.
    if kwargs: # If kwargs is not empty.
        print kwargs

>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func() takes at least 1 argument (0 given)

>>> func("required argument")
required argument

>>> func("required argument", 1, 2, '3')
required argument
(1, 2, '3')

>>> func("required argument", 1, 2, '3', keyword1=4, keyword2="foo")
required argument
(1, 2, '3')
{'keyword2': 'foo', 'keyword1': 4}



Ein Fall, in dem * args und ** kwargs nützlich sind, ist beim Schreiben von Wrapper-Funktionen (z. B. Dekoratoren), die in der Lage sein müssen, beliebige Argumente zu akzeptieren, die an die umwickelte Funktion übergeben werden. Zum Beispiel ein einfacher Decorator, der die Argumente und den Rückgabewert der umbrochenen Funktion ausgibt:

def mydecorator( f ):
   @functools.wraps( f )
   def wrapper( *args, **kwargs ):
      print "Calling f", args, kwargs
      v = f( *args, **kwargs )
      print "f returned", v
      return v
   return wrapper



Stellen Sie sich vor, Sie haben eine Funktion, aber Sie möchten die Anzahl der Parameter nicht einschränken. Beispiel:

>>> import operator
>>> def multiply(*args):
...  return reduce(operator.mul, args)

Dann verwenden Sie diese Funktion wie:

>>> multiply(1,2,3)
6

or

>>> numbers = [1,2,3]
>>> multiply(*numbers)
6



Beachten Sie, dass * args / ** kwargs Teil der funktionsaufrufenden Syntax und nicht wirklich ein Operator ist. Dies hat einen besonderen Nebeneffekt, den ich kennengelernt habe, nämlich dass Sie keine * args-Erweiterung mit der print-Anweisung verwenden können, da print keine Funktion ist.

Dies scheint vernünftig zu sein:

def myprint(*args):
    print *args

Leider kompiliert es nicht (Syntaxfehler).

Dies kompiliert:

def myprint(*args):
    print args

Aber druckt die Argumente als Tupel, was wir nicht wollen.

Das ist die Lösung, auf die ich mich eingelassen habe:

def myprint(*args):
    for arg in args:
        print arg,
    print



Sie können sich die Python-Dokumente ansehen (docs.python.org in den FAQ), aber speziell für eine gute Erklärung die mysteriösen Miss Args und Mister Kwargs (mit freundlicher Genehmigung von archive.org) (der ursprüngliche, tote Link ist hier ).

Kurz gesagt, beide werden verwendet, wenn optionale Parameter für eine Funktion oder Methode verwendet werden. Wie Dave sagt, wird * args verwendet, wenn Sie nicht wissen, wie viele Argumente übergeben werden können, und ** kwargs, wenn Sie Parameter verarbeiten möchten, die durch name und value wie folgt angegeben werden:

myfunction(myarg=1)



Related

python args kwargs