Python Language
* args i ** kwargs

Uwagi

Używanie * argumentów podczas pisania funkcji

Możesz użyć gwiazdki * podczas pisania funkcji, aby zebrać wszystkie argumenty pozycyjne (tj. Nienazwane) w krotce:

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

Metoda wywołania:

print_args(1, "two", 3)

W tej rozmowie farg zostanie przypisany jak zawsze, a dwaj pozostali zostaną wprowadzeni do krotki args, w kolejności ich otrzymania.

Używanie ** kwargs podczas pisania funkcji

Możesz zdefiniować funkcję, która pobierze dowolną liczbę argumentów słowa kluczowego (nazwanego), używając podwójnej gwiazdki ** przed nazwą parametru:

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

Podczas wywoływania metody Python konstruuje słownik wszystkich argumentów słów kluczowych i udostępnia go w treści funkcji:

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

Zauważ, że parametr ** kwargs w definicji funkcji musi zawsze być ostatnim parametrem i będzie pasował tylko do argumentów przekazanych po poprzednich.

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

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

Wewnątrz funkcji funkcja kwargs jest obsługiwana w taki sam sposób jak słownik; aby uzyskać dostęp do poszczególnych elementów w kwargs , po prostu przechodź przez nie tak, jak w przypadku zwykłego słownika:

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

Teraz wywołanie print_kwargs(a="two", b=1) pokazuje następujące dane wyjściowe:

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

Używanie * argumentów podczas wywoływania funkcji

Częstym przypadkiem użycia *args w definicji funkcji jest przekazanie przetwarzania do funkcji opakowanej lub odziedziczonej. Typowym przykładem może być metoda __init__ klasy

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

W tym a parametr jest przetwarzany przez klasę potomną po przekazaniu wszystkich innych argumentów (pozycyjnych i słów kluczowych) do klasy podstawowej i przetwarzanych przez nią.

Na przykład:

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

To, co się tutaj dzieje, to funkcja klasy B __init__ widzi argumenty 1, 2, 3 . Wie, że musi wziąć jeden argument pozycyjny ( a ), więc pobiera pierwszy argument przekazany w ( 1 ), więc w zakresie funkcji a == 1 .

Następnie widzi, że musi wziąć dowolną liczbę argumentów pozycyjnych ( *args ), więc bierze resztę argumentów pozycyjnych przekazanych w ( 1, 2 ) i umieszcza je w *args . Teraz (w zakresie funkcji) args == [2, 3] .

Następnie wywołuje funkcję __init__ klasy A z *args . Python widzi * przed argumentami i „rozpakowuje” listę na argumenty. W tym przykładzie, gdy klasa B 's __init__ funkcja nazywa klasa A ' s __init__ funkcja, zostanie on przekazany argumentów 2, 3 (czyli A(2, 3) ).

Na koniec ustawia własną właściwość x na pierwszy argument pozycyjny a , który jest równy 1 .

Używanie ** kwargs podczas wywoływania funkcji

Możesz użyć słownika, aby przypisać wartości do parametrów funkcji; używając nazwy parametru jako kluczy w słowniku i wartości tych argumentów powiązanych z każdym kluczem:

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) 

Używanie * argumentów podczas wywoływania funkcji

Efektem użycia operatora * na argumencie podczas wywoływania funkcji jest rozpakowanie listy lub argumentu krotkowego

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

Zauważ, że długość argumentu oznaczonego gwiazdką musi być równa liczbie argumentów funkcji.

Częstym idiomem python jest użycie operatora rozpakowywania * z funkcją zip do odwrócenia jego efektów:

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)

Argumenty zawierające tylko słowa kluczowe i wymagane słowa kluczowe

Python 3 pozwala definiować argumenty funkcji, które można przypisać tylko słowem kluczowym, nawet bez wartości domyślnych. Dokonuje się tego za pomocą gwiazdki *, aby zużywać dodatkowe parametry pozycyjne bez ustawiania parametrów słowa kluczowego. Wszystkie argumenty po * są tylko argumentami słów kluczowych (tj. Nie-pozycyjnymi). Zauważ, że jeśli argumentom zawierającym tylko słowa kluczowe nie podano wartości domyślnej, są one nadal wymagane podczas wywoływania funkcji.

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

Wypełnianie wartości kwarg za pomocą słownika

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

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

foobar(**values) # "foobar"

** kwargs i wartości domyślne

Aby użyć wartości domyślnych z ** kwargs

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

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