Iterating Over Tuples and Dictionaries

Why Variable Inputs Matter

Suppose a function must add numbers, but one user supplies three numbers while another supplies five or ten. Defining a separate function for every possible number of inputs would be impractical. Python provides variable argument lists so one function can accept an unknown number of arguments. The asterisk syntax collects extra positional arguments, and the double-asterisk syntax collects keyword arguments.

Packing Positional Arguments

When a function defines a parameter such as *numbers, Python collects the extra positional arguments supplied at the call site into one tuple named numbers inside the function. The tuple preserves the order in which the positional arguments were supplied. Because numbers is a tuple, the function can process it with a loop just as it would process any other tuple.

def total(initial, *numbers): result = initial for number in numbers: result = result + number return result answer = total(10, 1, 2, 3) print(answer)

Packing Keyword Arguments

A parameter written as **keywords collects keyword arguments into a dictionary. Each keyword supplies a name and a value, so the function can process the collected key-value pairs. Since keywords behaves like a dictionary inside the function, it can be iterated over like any other dictionary.

def total(initial, *numbers, **keywords): result = initial for number in numbers: result = result + number for value in keywords.values(): result = result + value return result answer = total(10, 1, 2, 3, vegetables=50, fruits=100) print(answer)

Tracing a Flexible Calculation

def multiply_and_sum(multiplier, *numbers):
    result = 0
    for number in numbers:
        result = result + multiplier * number
    return result

print(multiply_and_sum(2, 1, 2, 3))
print(multiply_and_sum(1, 5, 10, 15))
print(multiply_and_sum(3, 4, 5))

12
30
27

The same function handles all three calls even though each call supplies a different number of values after multiplier. In the first call, the tuple is (1, 2, 3), so the calculation is 2 times 1 plus 2 times 2 plus 2 times 3, which equals 12. In the second call, the tuple is (5, 10, 15), producing 30. In the third call, the tuple is (4, 5), producing 27.

Choosing a Clear Function Design

Mistakes with Variable Arguments

• Putting parameters in the wrong order.

  The required order is fixed parameters, then *args, then **kwargs. Python enforces this order.

  Fix: Place initial first, numbers second, and keywords last: def total(initial, *numbers, **keywords):

• Treating *args as one individual value instead of a tuple.

  *args collects the extra positional arguments into a tuple, so the function must process the tuple's items.

  Fix: Iterate over numbers to process each collected positional value.

• Treating **kwargs as a single value instead of a dictionary.

  **kwargs collects the keyword arguments into a dictionary.

  Fix: Iterate over the dictionary or its values to process the supplied keyword arguments.

• Using variable arguments when the number of inputs is always known.

  Variable arguments can make a function less clear when its input count is already fixed.

  Fix: Define the expected parameters explicitly.

Practice the Argument Flow

1. Variable argument lists let one function accept an unknown number of inputs. Extra positional arguments collected with *args become a tuple, while keyword arguments collected with **kwargs become a dictionary. Both collections can be iterated over inside the function. Keep the parameter order fixed: regular parameters first, *args next, and **kwargs last. Use this flexibility when the number of inputs is genuinely variable, but prefer explicit parameters when the function's inputs are always known.