Python Function Arguments Practice: defaults, *args, keyword-only, **kwargs

Python function parameters follow this strict order:

def f(positional_only, /, positional_or_keyword, *args, keyword_only, **kwargs)

Example combining everything:

def api_call(endpoint, /, method="GET", *args, headers=None, **options):
    # endpoint: positional-only (callers use: api_call("/users"))
    # method: positional or keyword
    # *args: extra positional arguments
    # headers: keyword-only (must be: headers={...})
    # **options: remaining keyword arguments
    pass

Here's how it bites you:

def append_to(item, target=[]):  # BUG!
    target.append(item)
    return target

append_to(1)  # [1]
append_to(2)  # [1, 2] — wait, what?
append_to(3)  # [1, 2, 3] — it's accumulating!

Why it happens: Default values are evaluated once when the function is defined, not when it's called. The empty list [] is created once and reused for every call that doesn't provide target.

The fix: Use None as a sentinel and create a fresh container inside:

def append_to(item, target=None):
    if target is None:
        target = []  # New list each time
    target.append(item)
    return target

This pattern applies to any mutable default: lists, dicts, sets, and custom objects. If you're coming from JavaScript, Python vs JavaScript functions covers how default parameters differ between the two languages.

Put a bare * in your signature to make all following parameters keyword-only:

def connect(*, host, port, timeout=30):
    ...

# Caller MUST use keyword syntax:
connect(host="localhost", port=8080)  # OK
connect("localhost", 8080)  # TypeError!

When to use keyword-only:

• Parameters that are easily confused (is it (width, height) or (height, width)?)
• Boolean flags that need context (force=True is clearer than just True)
• Optional parameters that shouldn't be passed positionally

If you also need *args, keyword-only parameters come after:

def log(message, *args, level="INFO"):
    # *args captures extra positional arguments
    # level is keyword-only
    print(f"[{level}]", message % args)

Put a / in your signature to make all preceding parameters positional-only:

def greet(name, /):
    return f"Hello, {name}!"

greet("Alice")       # OK
greet(name="Alice")  # TypeError: positional-only

When to use positional-only:

• The parameter name is an implementation detail (you might rename it later)
• Keyword syntax would be awkward or confusing
• Matching behavior of built-ins like len(obj) (you can't write len(obj=...))

Combining both:

def divmod(a, b, /):
    # Matches the built-in: positional-only
    return a // b, a % b

TypeError: got multiple values for argument 'x'

You passed a value both positionally AND as a keyword:

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice", name="Bob")  # TypeError!
# "Alice" goes to 'name', then name="Bob" tries to set it again

Fixes:

1. Remove the duplicate: greet("Alice")
2. Make name positional-only: def greet(name, /, message="Hello")

TypeError: missing 1 required keyword-only argument

A keyword-only parameter without a default wasn't provided:

def connect(*, host, port):
    ...

connect(host="localhost")  # TypeError: missing 'port'

Fix: Pass the required argument: connect(host="localhost", port=8080)

TypeError: takes N positional arguments but M were given

Too many positional arguments:

def add(a, b):
    return a + b

add(1, 2, 3)  # TypeError: takes 2 but 3 were given

Fixes:

1. Pass fewer arguments
2. Add *args to capture extras: def add(*args): return sum(args)
3. In methods, remember self counts as the first argument

The Strategy design pattern relies on passing different functions (or lambdas) to change an object's behavior at runtime — a natural fit for Python's first-class functions.

Lambdas are anonymous single-expression functions:

# As a key function
sorted(users, key=lambda u: u.name)

# In higher-order functions
list(map(lambda x: x ** 2, numbers))

# Callbacks
button.on_click(lambda event: print("Clicked!"))

When to prefer def:

• Multiple statements needed
• Complex logic that deserves a name
• You need a docstring or type hints
• Debugging (named functions have better tracebacks)

The closure trap

Lambdas capture variables by reference, not value:

# BUG: all lambdas see i=2 (the final value)
funcs = [lambda: i for i in range(3)]
[f() for f in funcs]  # [2, 2, 2]

# FIX: capture current value via default argument
funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]  # [0, 1, 2]

Python resolves names by searching four scopes in order: Local, Enclosing, Global, Built-in (LEGB).

Variables assigned inside a function are local by default:

x = 10

def modify():
    x = 20  # Creates a LOCAL x, doesn't touch global
    print(x)  # 20

modify()
print(x)  # 10 — global unchanged

To modify a global variable, use the global keyword:

x = 10

def modify():
    global x
    x = 20  # Now modifies the global

modify()
print(x)  # 20

For nested functions, use nonlocal to modify an enclosing scope:

def outer():
    count = 0

    def increment():
        nonlocal count
        count += 1

    increment()
    increment()
    return count  # 2

General advice: Avoid global when possible—it makes code harder to reason about. Prefer returning values and passing arguments. Rust enforces ownership rules that eliminate many of the scoping bugs Python developers encounter — see Python vs Rust functions for the comparison.

The * and ** operators work in function calls too:

def greet(name, greeting, punctuation):
    return f"{greeting}, {name}{punctuation}"

# Unpack a list/tuple as positional arguments
args = ["Alice", "Hello", "!"]
greet(*args)  # "Hello, Alice!"

# Unpack a dict as keyword arguments
kwargs = {"name": "Bob", "greeting": "Hi", "punctuation": "?"}
greet(**kwargs)  # "Hi, Bob?"

# Combine both
greet(*["Alice"], **{"greeting": "Hey", "punctuation": "."})

This is especially useful for forwarding arguments:

def wrapper(*args, **kwargs):
    print("Before")
    result = original_function(*args, **kwargs)
    print("After")
    return result

• Python Tutorial: Defining Functions
• Python Tutorial: More on Defining Functions
• Python FAQ: Why are default values shared between objects?
• PEP 570 – Positional-Only Parameters
• PEP 3102 – Keyword-Only Arguments
• Python Reference: Lambda expressions