Python Language
* args und ** kwargs

Bemerkungen

Verwenden von * args beim Schreiben von Funktionen

Sie können den Stern * beim Schreiben einer Funktion verwenden, um alle positionellen (dh unbenannten) Argumente in einem Tupel zu sammeln:

def print_args(farg, *args):
   print("formal arg: %s" % farg)
   for arg in args:
       print("another positional arg: %s" % arg)

Aufrufmethode:

print_args(1, "two", 3)

In diesem Aufruf wird farg wie immer zugewiesen, und die beiden anderen werden in der Reihenfolge, in der sie empfangen wurden, dem Args-Tupel zugeführt.

Verwenden von ** Warnungen beim Schreiben von Funktionen

Sie können eine Funktion definieren, die eine beliebige Anzahl von Schlüsselwort (benannten) Argumenten verwendet, indem Sie den doppelten Stern ** vor einem Parameternamen verwenden:

def print_kwargs(**kwargs):
    print(kwargs)

Beim Aufruf der Methode erstellt Python ein Wörterbuch aller Schlüsselwortargumente und macht es im Funktionskörper verfügbar:

print_kwargs(a="two", b=3)
# prints: "{a: "two", b=3}"

Beachten Sie, dass der ** kwargs-Parameter in der Funktionsdefinition immer der letzte Parameter sein muss und nur mit den Argumenten übereinstimmt, die nach den vorherigen übergeben wurden.

def example(a, **kw):
    print kw

example(a=2, b=3, c=4) # => {'b': 3, 'c': 4}

Innerhalb des Funktionskörpers wird kwargs wie ein Wörterbuch manipuliert. Um auf einzelne Elemente in kwargs zuzugreifen, kwargs Sie diese wie bei einem normalen Wörterbuch:

def print_kwargs(**kwargs):
    for key in kwargs:
        print("key = {0}, value = {1}".format(key, kwargs[key])) 

print_kwargs(a="two", b=1) aufrufen, wird die folgende Ausgabe print_kwargs(a="two", b=1) :

print_kwargs(a = "two", b = 1)
key = a, value = "two"
key = b, value = 1

Verwendung von * args beim Aufruf von Funktionen

Ein häufiger Anwendungsfall für *args in einer Funktionsdefinition ist das Delegieren der Verarbeitung an eine umschlossene oder geerbte Funktion. Ein typisches Beispiel ist die __init__ Methode einer Klasse

class A(object):
    def __init__(self, b, c):
        self.y = b
        self.z = c

class B(A):
    def __init__(self, a, *args, **kwargs):
        super(B, self).__init__(*args, **kwargs)
        self.x = a

Hier wird der a wird der Parameter von der Kind - Klasse , nachdem alle anderen Argumente verarbeitet (Lage- und Keyword) geleitet werden , auf - und verarbeitet - der Basisklasse.

Zum Beispiel:

b = B(1, 2, 3)
b.x  # 1
b.y  # 2
b.z  # 3

Was hier passiert, ist, dass die Klasse B __init__ die Argumente 1, 2, 3 sieht. Es weiß, dass es ein positionelles Argument ( a ) braucht, daher greift es das erste Argument, das in ( 1 ) übergeben wurde, also im Bereich der Funktion a == 1 .

Als nächstes sieht es, dass es eine beliebige Anzahl von Positionsargumenten ( *args ) nehmen muss, sodass es den Rest der übergebenen Positionsargumente ( 1, 2 ) übernimmt und in *args stopft. Nun (im Umfang der Funktion) args == [2, 3] .

Dann ruft es die Funktion __init__ Klasse A mit *args . Python sieht das * vor args und "entpackt" die Liste in Argumente. Wenn in diesem Beispiel die __init__ Funktion der Klasse B die __init__ Funktion der Klasse A __init__ , werden die Argumente 2, 3 (dh A(2, 3) ) übergeben.

Schließlich setzt es seine eigene x Eigenschaft auf das erste Positionsargument a , das gleich 1 .

Verwenden von ** Warnungen beim Aufruf von Funktionen

Sie können ein Wörterbuch verwenden, um den Parametern der Funktion Werte zuzuweisen. Verwenden Sie den Parameternamen als Schlüssel im Wörterbuch und den Wert dieser an jeden Schlüssel gebundenen Argumente:

def test_func(arg1, arg2, arg3): # Usual function with three arguments
   print("arg1: %s" % arg1)
   print("arg2: %s" % arg2)
   print("arg3: %s" % arg3)

# Note that dictionaries are unordered, so we can switch arg2 and arg3. Only the names matter.
kwargs = {"arg3": 3, "arg2": "two"}

# Bind the first argument (ie. arg1) to 1, and use the kwargs dictionary to bind the others
test_var_args_call(1, **kwargs) 

Verwendung von * args beim Aufruf von Funktionen

Die Verwendung des Operators * für ein Argument beim Aufruf einer Funktion hat den Effekt, dass die Liste oder ein Tupel-Argument entpackt wird

def print_args(arg1, arg2):
    print(str(arg1) + str(arg2))

a = [1,2]
b = tuple([3,4])

print_args(*a)
# 12
print_args(*b)
# 34

Beachten Sie, dass die Länge des mit Sternchen versehenen Arguments der Anzahl der Argumente der Funktion entsprechen muss.

Ein übliches Python-Idiom besteht darin, den Entpackungsoperator * mit der zip Funktion zu verwenden, um seine Auswirkungen umzukehren:

a = [1,3,5,7,9]
b = [2,4,6,8,10]

zipped = zip(a,b)
# [(1,2), (3,4), (5,6), (7,8), (9,10)]

zip(*zipped)
# (1,3,5,7,9), (2,4,6,8,10)

Nur für Schlüsselwörter und für Schlüsselwörter erforderliche Argumente

In Python 3 können Sie Funktionsargumente definieren, die auch ohne Standardwerte nur per Schlüsselwort zugewiesen werden können. Dies erfolgt durch Verwendung von Stern *, um zusätzliche Positionsparameter zu verwenden, ohne die Schlüsselwortparameter festzulegen. Alle Argumente nach dem * sind Argumente, die nur aus einem Schlüsselwort bestehen. Beachten Sie, dass Argumente, die nur aus Schlüsselwörtern bestehen, keinen Standardwert haben, beim Aufruf der Funktion jedoch erforderlich sind.

def print_args(arg1, *args, keyword_required, keyword_only=True):
    print("first positional arg: {}".format(arg1))
    for arg in args:
        print("another positional arg: {}".format(arg))
    print("keyword_required value: {}".format(keyword_required))
    print("keyword_only value: {}".format(keyword_only))
    
print(1, 2, 3, 4) # TypeError: print_args() missing 1 required keyword-only argument: 'keyword_required'
print(1, 2, 3, keyword_required=4) 
# first positional arg: 1
# another positional arg: 2
# another positional arg: 3
# keyword_required value: 4
# keyword_only value: True

Kwarg-Werte mit einem Wörterbuch füllen

def foobar(foo=None, bar=None):
    return "{}{}".format(foo, bar)

values = {"foo": "foo", "bar": "bar"}

foobar(**values) # "foobar"

** Warnungen und Standardwerte

So verwenden Sie Standardwerte mit ** kwargs

def fun(**kwargs):
    print kwargs.get('value', 0)

fun()
# print 0
fun(value=1)
# print 1