Use f(my_tuple) when a function should receive one tuple object. Use f(*my_tuple) when the tuple’s items should become separate positional arguments. The function signature determines which form is right.
Pass a tuple as one argument
Calling a function with the tuple name passes the tuple intact. The function receives one argument and can unpack its contents inside its body.
def describe(person):
name, age = person
return f"{name} is {age}"
person = ("Ada", 36)
print(describe(person))Here, describe has one parameter, person. Inside the function, name, age = person assigns the tuple’s two values to local variables.
Unpack tuple items into separate positional arguments
Put * before the tuple at the call site to expand its items into positional arguments. The function must have a matching parameter for each item, in the right order.
#1 Best Overall
def describe(name, age):
return f"{name} is {age}"
person = ("Ada", 36)
print(describe(*person))This is equivalent to calling describe("Ada", 36). Python’s tutorial on unpacking argument lists uses the same pattern with range(*args).
| Call | Arguments received | Suitable signature |
|---|---|---|
f(values) |
One argument: the tuple values |
def f(values): |
f(*values) |
One positional argument per tuple item | For two items: def f(first, second): |
Python’s built-in types documentation likewise distinguishes f(a, b, c), which passes three arguments, from f((a, b, c)), which passes one 3-tuple.
Collect positional arguments with *args
In a function definition, *args collects extra positional arguments into a tuple. This is the reverse direction from *values in a call, which expands an iterable into arguments.
def report(first, *args):
print("first:", first)
print("remaining positional arguments:", args)
report("a", "b", "c")The call prints first: a and then remaining positional arguments: ('b', 'c'). The parameter name args is conventional; the asterisk gives it this collecting behavior.
Recommended Free Tools
Forward positional and keyword arguments
A wrapper can collect positional arguments in a tuple and keyword arguments in a dictionary, then pass both on to another function:
def wrapper(*args, **kwargs):
return target(*args, **kwargs)Use * to expand positional values from a tuple or other iterable. Use ** to expand keyword arguments from a mapping of names to values; it is not the way to unpack tuple items. See the Python FAQ’s explanation of argument collection and forwarding.
Choose the call from the function signature
- If the function has one parameter meant to hold a tuple, call it as
f(values). - If the function has a separate parameter for each tuple item, call it as
f(*values). - After expansion, check that the number and order of positional values match the parameters. For keyword arguments, check that each name is accepted.
For example, if a function expects two positional parameters, f(values) supplies too few arguments: it passes just one tuple. Conversely, f(*values) supplies too many if the function expects one tuple-valued parameter and the tuple has several items.
Fix common tuple argument errors
- Wrong argument count: Choose between
f(values)andf(*values)based on the function’s parameters. - Duplicate parameter value: Do not supply the same parameter once positionally and again by name. For example,
function(0, a=0)raises aTypeErrorif both values target parametera. - Using
**with a tuple: Keyword expansion needs a mapping with keyword names. Use*to expand tuple items positionally. - Missing comma in a one-item tuple: Write
(5,), not(5). The latter is the integer5, because the comma—not the parentheses—makes a tuple, as the built-in types documentation notes.
Annotate tuple parameters and variadic arguments
When a function receives a tuple intact, annotate the tuple-valued parameter. For example, tuple[int, int] describes a two-item tuple of integers:
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →def consume(point: tuple[int, int]) -> None:
...For a function that collects positional arguments, *args: int indicates that each collected argument is an integer. Python 3.14’s typing documentation also covers type variable tuples and *args: *Ts for preserving a callable’s varying positional argument types. Choose annotation forms supported by the Python versions your project targets.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
