*args i **kwargs w Pythonie: elastyczne argumenty pozycyjne i nazwane

Gdy nie wiesz, ile będzie argumentów

Większość funkcji przyjmuje stałą liczbę parametrów. Czasem jednak potrzebujesz czegoś bardziej elastycznego: loggera, który przyjmuje dowolną liczbę komunikatów, funkcji opakowującej, która przekazuje wszystko, co dostała, do innej funkcji, albo funkcji rysującej wykresy, która przyjmuje konfigurację, nie wiedząc dokładnie, jakich opcji użyje wywołujący.

Python rozwiązuje to dwoma specjalnymi znacznikami na liście parametrów: *args i **kwargs.

*args zbiera argumenty pozycyjne

Pojedyncza gwiazdka oznacza "spakuj wszystkie dodatkowe argumenty pozycyjne w krotkę":

def log_all(*args):
    for message in args:
        print("LOG:", message)

log_all("starting")
log_all("ready", "set", "go")
log_all()    # zero argumentów też jest w porządku

Wewnątrz funkcji args to zwykła krotka. Możesz iterować po niej pętlą, odwoływać się do elementów przez indeks, przekazać ją do len() albo ją wycinać.

*args zwykle występuje obok nazwanych parametrów:

def first_then_rest(first, *rest):
    print("first:", first)
    print("rest:", rest)

first_then_rest("a")
first_then_rest("a", "b", "c", "d")

first przechwytuje pierwszy argument, a *rest pakuje wszystko, co po nim, w krotkę.

**kwargs zbiera argumenty nazwane

Dwie gwiazdki robią to samo dla argumentów nazwanych, pakując je w słownik:

def describe(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

describe(name="Rosa", age=30, city="Lisbon")

Wewnątrz describe zmienna kwargs to zwykły słownik. Kluczami są nazwy argumentów jako napisy.

Używanie obu naraz

Możesz użyć obu w tej samej funkcji. Konwencja to *args przed **kwargs:

def show(**kwargs):
    print(kwargs)

def logger(*args, **kwargs):
    print("positional:", args)
    print("keyword:", kwargs)

logger(1, 2, 3, level="warn", tag="api")

Pełna kolejność parametrów, od pierwszego do ostatniego, wygląda tak:

1. Zwykłe parametry pozycyjne (wymagane lub z wartościami domyślnymi).
2. *args.
3. Parametry tylko nazwane (wszystko po *args trzeba przekazać przez nazwę).
4. **kwargs.

def post(title, *tags, draft=False, **metadata):
    print(title, tags, draft, metadata)

post("Hello", "python", "docs", draft=True, author="Rosa")

title przechwytuje pierwszy argument pozycyjny. Pozostałe pozycyjne trafiają do tags. draft trzeba przekazać przez nazwę (występuje po *tags). Wszystkie inne argumenty nazwane lądują w metadata.

Rozpakowywanie przez * i ** przy wywołaniu

Gwiazdki działają też w drugą stronę: rozkładają sekwencję albo słownik na argumenty wywołania:

def area(width, height):
    return width * height

dimensions = (4, 5)
print(area(*dimensions))       # rozkłada krotkę na dwa argumenty

options = {"width": 4, "height": 5}
print(area(**options))         # rozkłada słownik na argumenty nazwane

To niezwykle przydatne przy przekazywaniu argumentów dalej:

def log(level, message):
    print(f"[{level}] {message}")

def wrapped(*args, **kwargs):
    print("before")
    result = log(*args, **kwargs)
    print("after")
    return result

wrapped("info", "starting up")
wrapped(level="warn", message="retrying")

wrapped nie musi wiedzieć, jakich argumentów oczekuje log. Po prostu zbiera wszystko i przekazuje dalej. Ten wzorzec pojawia się bardzo często w dekoratorach (temat dla bardziej zaawansowanych) i funkcjach opakowujących.

Kiedy *args i **kwargs to zły wybór

Łatwo dać się ponieść i używać ich wszędzie. Dwa ostrzeżenia:

Ukrywają, czego funkcja oczekuje

Jeśli każda funkcja w twoim kodzie wygląda jak def f(*args, **kwargs), kod wywołujący nie ma pojęcia, jakie argumenty są poprawne. Używaj nazwanych parametrów, kiedy tylko możesz, a *args/**kwargs zostaw dla naprawdę zmiennej liczby wejść albo czystego przekazywania dalej.

Komunikaty o błędach stają się niejasne

Literówka w nazwie argumentu zamienia się w cichy None albo w KeyError głęboko w funkcji, zamiast natychmiastowego "unexpected keyword argument" w miejscu wywołania. Nazwane parametry dają dużo lepszą informację zwrotną.

Zasada: domyślnie wybieraj nazwane parametry, a po *args/**kwargs sięgaj tylko wtedy, gdy funkcja jest naprawdę elastyczna albo przekazuje argumenty do innego obiektu wywoływalnego.

Mały praktyczny przykład

Pomocnik w stylu funkcji do wykresów, który opakowuje funkcję z zewnętrznej biblioteki kilkoma wartościami domyślnymi:

def styled_print(*values, sep=" | ", end="\n", **style):
    prefix = style.get("prefix", "")
    suffix = style.get("suffix", "")
    message = sep.join(str(v) for v in values)
    print(prefix + message + suffix, end=end)

styled_print("user", "action", "timestamp")
styled_print("a", "b", "c", sep=" > ", prefix="[info] ")
styled_print(42, True, None, prefix=">>> ", suffix=" <<<")

*values pozwala wywołującym przekazać dowolną liczbę elementów, a **style przyjmuje dodatkową konfigurację bez wymogu, by każda opcja była nazwanym parametrem. Jest to elastyczne, a jednocześnie czytelne, bo wewnętrzna logika mówi dokładnie, jakie klucze odczytuje ze style.

Podsumowanie

• *args pakuje dodatkowe argumenty pozycyjne w krotkę.
• **kwargs pakuje dodatkowe argumenty nazwane w słownik.
• Przy wywołaniu *seq i **dict rozpakowują w przeciwną stronę.
• Parametry muszą występować w kolejności: zwykłe → *args → tylko nazwane → **kwargs.
• Nie nadużywaj ich: nazwane parametry są czytelniejsze, gdy możesz ich użyć.

Dalej: lambda, sposób na pisanie małych, jednorazowych funkcji w jednej linii.