Python *args und **kwargs: flexible positionelle und Keyword-Argumente

Wenn du nicht weißt, wie viele Argumente es werden

Die meisten Funktionen nehmen eine feste Anzahl Parameter. Gelegentlich brauchst du mehr Flexibilität — einen Logger, der beliebig viele Nachrichten annimmt, eine Wrapper-Funktion, die alles Eingegangene an eine andere Funktion weiterreicht, eine Plot-Funktion, die Konfiguration akzeptiert, ohne genau zu wissen, welche Optionen der Aufrufer nutzt.

Python löst das mit zwei besonderen Markierungen in der Parameterliste: *args und **kwargs.

*args sammelt positionelle Argumente

Ein einzelnes Sternchen heißt „packe alle zusätzlichen positionellen Argumente in ein Tupel“:

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

log_all("starting")
log_all("ready", "set", "go")
log_all()    # zero arguments is fine

Innerhalb der Funktion ist args ein normales Tupel. Du kannst darüber schleifen, es indizieren, len() aufrufen oder slicen.

*args erscheint meist neben benannten Parametern:

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

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

first nimmt das erste Argument; *rest packt alles danach in ein Tupel.

**kwargs sammelt Keyword-Argumente

Zwei Sternchen machen das Gleiche für Keyword-Argumente und packen sie in ein Dict:

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

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

Innerhalb von describe ist kwargs ein normales Dict. Die Schlüssel sind die Keyword-Namen als Strings.

Beide zusammen nutzen

Du kannst beide in derselben Funktion verwenden. Konvention: *args vor **kwargs:

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

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

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

Die vollständige Parameterreihenfolge von links nach rechts:

1. Normale positionelle Parameter (mit oder ohne Default).
2. *args.
3. Keyword-gebundene Parameter (alles nach *args muss per Schlüsselwort übergeben werden).
4. **kwargs.

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

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

title nimmt das erste positionelle. Der Rest der positionellen geht in tags. draft muss per Schlüsselwort übergeben werden (es steht nach *tags). Weitere Keyword-Argumente landen in metadata.

Entpacken mit * und ** am Aufrufort

Die Sterne funktionieren auch umgekehrt — eine Sequenz oder ein Dict in die Argumente eines Aufrufs ausbreiten:

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

dimensions = (4, 5)
print(area(*dimensions))       # spreads the tuple into two args

options = {"width": 4, "height": 5}
print(area(**options))         # spreads the dict into keyword args

Das ist unglaublich praktisch zum Weiterleiten von Argumenten:

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 muss nicht wissen, welche Argumente log erwartet. Es sammelt alles und reicht es weiter. Dieses Muster taucht bei Dekoratoren (fortgeschrittener Stoff) und Wrapper-Funktionen ständig auf.

Wann *args und **kwargs die falsche Wahl sind

Es ist leicht, sich zu begeistern und sie überall einzusetzen. Zwei Warnungen:

Sie verbergen, was eine Funktion erwartet

Ist jede Funktion in deiner Codebase def f(*args, **kwargs), weiß der aufrufende Code nicht, welche Argumente gültig sind. Nutz benannte Parameter, wann immer du kannst, und lass *args/**kwargs nur echt variable Eingaben oder reines Weiterleiten tragen.

Fehlermeldungen werden vage

Ein falsch getippter Keyword-Name wird zu einem stillen None oder einem KeyError tief in der Funktion, statt einer sofortigen „unexpected keyword argument“-Meldung am Aufrufort. Benannte Parameter geben dir viel besseres Feedback.

Als Regel: bevorzug standardmäßig benannte Parameter und greif zu *args/**kwargs nur, wenn die Funktion echt flexibel ist oder Argumente an einen anderen Aufruf weiterleitet.

Ein kleines praktisches Beispiel

Ein Plot-ähnlicher Helfer, der eine Drittanbieterfunktion mit ein paar Defaults umschließt:

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 erlaubt Aufrufern, beliebig viele Elemente zu übergeben; **style schluckt zusätzliche Konfiguration, ohne dass jede Option ein benannter Parameter sein muss. Flexibel, aber nicht undurchsichtig, weil die innere Logik genau zeigt, welche Schlüssel aus style gelesen werden.

Zusammenfassung

• *args packt zusätzliche positionelle Argumente in ein Tupel.
• **kwargs packt zusätzliche Keyword-Argumente in ein Dict.
• Am Aufrufort entpacken *seq und **dict in die andere Richtung.
• Parameter müssen in der Reihenfolge erscheinen: normal → *args → keyword-only → **kwargs.
• Nicht übertreiben — benannte Parameter sind klarer, wenn du sie nutzen kannst.

Als Nächstes: lambda, ein Weg, winzige Einweg-Funktionen inline zu schreiben.