Python Language
* args och ** kwargs

Anmärkningar

Använda * args när du skriver funktioner

Du kan använda stjärnan * när du skriver en funktion för att samla alla positionella (dvs. Ej namngivna) argument i en tupel:

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

Ringmetod:

print_args(1, "two", 3)

I det samtalet kommer farg att tilldelas som alltid, och de två andra matas in i args-tupeln, i den ordning de mottogs.

Använda ** kwargs när du skriver funktioner

Du kan definiera en funktion som tar ett godtyckligt antal nyckelord (namngivna) argument med hjälp av dubbelstjärnan ** före ett parameternamn:

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

När man ringer till metoden kommer Python att konstruera en ordlista med alla sökordargument och göra den tillgänglig i funktionskroppen:

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

Observera att ** kwargs-parametern i funktionsdefinitionen alltid måste vara den sista parametern, och den kommer bara att matcha de argument som lämnades in efter de tidigare.

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

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

Inuti funktionskroppen manipuleras kwargs på samma sätt som en ordbok; för att få åtkomst till enskilda element i kwargs du bara igenom dem som du skulle göra med en vanlig ordbok:

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

Nu, att ringa print_kwargs(a="two", b=1) visar följande utgång:

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

Använda * args när du ringer funktioner

Ett vanligt användningsfall för *args i en funktionsdefinition är att delegera behandlingen till antingen en lindad eller ärvd funktion. Ett typiskt exempel kan vara i klassens __init__ metod

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

Här a är parameter behandlas av barnklassen när alla andra argument (positions och sökord) förs in - och behandlas av - basklass.

Till exempel:

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

Det som händer här är funktionen klass B __init__ ser argumenten 1, 2, 3 . Den vet att den måste ta ett positionsargument ( a ), så det tar det första argumentet som skickats in ( 1 ), så inom ramen för funktionen a == 1 .

Därefter ser den att den måste ta ett godtyckligt antal positionella argument ( *args ) så det tar resten av positioneringsargumenten som skickas in ( 1, 2 ) och fyller dem i *args . Nu (inom ramen för funktionen) args == [2, 3] .

Sedan kallar den klass A : s __init__ funktion med *args . Python ser * framför args och "packar upp" listan i argument. I det här exemplet, när klass B : s __init__ funktion anropar klass A : s __init__ funktion, kommer det att passeras argumenten 2, 3 (dvs. A(2, 3) ).

Slutligen sätter den sin egen x egenskap till det första positionsargumentet a , vilket är lika med 1 .

Med ** kwargs när du ringer funktioner

Du kan använda en ordlista för att tilldela värden till funktionens parametrar; använda parametrarnamn som nycklar i ordboken och värdet på dessa argument som är bundna till varje nyckel:

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) 

Använda * args när du ringer funktioner

Effekten av att använda operatören * på ett argument när du ringer till en funktion är att packa upp listan eller ett tupelargument

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

Observera att längden på det stjärnmärkta argumentet måste vara lika med antalet av funktionens argument.

En vanlig pythonidiom är att använda uppackningsoperatören * med zip funktionen för att vända dess effekter:

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)

Argument med bara sökord och sökord

Python 3 låter dig definiera funktionsargument som bara kan tilldelas med nyckelord, även utan standardvärden. Detta görs genom att använda star * för att konsumera ytterligare positionsparametrar utan att ställa in sökordsparametrarna. Alla argument efter * är endast sökord (dvs. icke-positionella) argument. Observera att om argument med bara nyckelord inte har något standard, krävs de fortfarande när du ringer funktionen.

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

Populera kwarg-värden med en ordlista

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

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

foobar(**values) # "foobar"

** kwargs och standardvärden

För att använda standardvärden med ** kwargs

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

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