How to Pass a Tuple to a Function in Python

There are two ways to pass a tuple to a function in Python. Pass it as it is, f(t), and the function gets one tuple. Put a star in front, f(*t), and each item becomes its own positional argument:

point = (3, 4)
show(point)    # one argument: (3, 4)
show(*point)   # two arguments: 3, 4

The outputs and screenshots below come from Python 3.12.5 in Command Prompt, with US mailing addresses and shopping-cart prices as sample data.

In this tutorial, we’ll pass a tuple whole, unpack it with *, use *args, and handle lists of tuples and keyword arguments.

Pass a tuple as a single argument

When the values belong together, like an address, pass the tuple itself and unpack it inside the function:

def ship_label(address):
    street, city, state = address        # unpack inside the function
    return f"{street}, {city}, {state}"

office = ("350 5th Ave", "New York", "NY")
print(ship_label(office))

Output:

350 5th Ave, New York, NY

This is the mirror image of returning a tuple from a Python function, where one function hands several values back as a single tuple.

Unpack a tuple into function arguments with the * operator

If the function expects separate parameters, add * at the call site. Python spreads the tuple across the parameters in order. The item count must match, or you get a TypeError:

def ship_label(street, city, state):
    return f"{street}, {city}, {state}"

office = ("350 5th Ave", "New York", "NY")
print(ship_label(*office))               # same as ship_label("350 5th Ave", "New York", "NY")

try:
    ship_label(*("1 Main St", "Austin"))
except TypeError as e:
    print("TypeError:", e)

Output:

350 5th Ave, New York, NY
TypeError: ship_label() missing 1 required positional argument: 'state'

The same star works outside function calls too; see unpacking a tuple in Python for starred assignment and ignoring values with _.

How does *args turn arguments into a tuple?

* in the def line does the reverse: it packs any number of positional arguments into a tuple, whether they come from *cart or loose values:

def order_total(*prices):
    print("prices is a", type(prices).__name__, prices)
    return round(sum(prices), 2)

cart = (19.99, 5.25, 3.50)
print(order_total(*cart))
print(order_total(cart[0], 10.00))

Output:

prices is a tuple (19.99, 5.25, 3.5)
28.74
prices is a tuple (19.99, 10.0)
29.99

I cover the keyword side, **kwargs, in the difference between *args and **kwargs in Python.

Pass a list of tuples to a function

With rows of data, loop over the list and unpack each tuple into the call, or let itertools.starmap() do it:

from itertools import starmap

def line_total(item, qty, price):
    return f"{item:<8} {qty} x ${price:.2f} = ${qty * price:.2f}"

orders = [("Mug", 2, 12.50), ("Poster", 1, 24.00), ("Pen", 10, 1.25)]

for order in orders:
    print(line_total(*order))

print(list(starmap(line_total, orders))[0])

Output:

Mug      2 x $12.50 = $25.00
Poster   1 x $24.00 = $24.00
Pen      10 x $1.25 = $12.50
Mug      2 x $12.50 = $25.00

For more ways to walk through rows like these, read iterating through tuples in Python.

Mix a tuple with keyword arguments

You can unpack a tuple for the first parameters and pass the rest by name with a ** dict:

def invoice(customer, amount, currency="USD", due="2026-11-15"):
    return f"{customer}: {amount:.2f} {currency}, due {due}"

row = ("Emily Carter", 149.5)
options = {"due": "2026-12-01"}
print(invoice(*row))
print(invoice(*row, **options))

Output:

Emily Carter: 149.50 USD, due 2026-11-15
Emily Carter: 149.50 USD, due 2026-12-01

Keyword values have to come after the unpacked tuple. Defaults like currency="USD" are explained in Python functions with optional arguments.

Can a function change a tuple you pass in?

No. Tuples are immutable, so item assignment raises an error. Return a new tuple instead:

def add_tax(prices):
    try:
        prices[0] = prices[0] * 1.08
    except TypeError as e:
        print("TypeError:", e)
    return tuple(round(p * 1.08, 2) for p in prices)

cart = (10.00, 20.00)
new_cart = add_tax(cart)
print(cart, new_cart)

Output:

TypeError: 'tuple' object does not support item assignment
(10.0, 20.0) (10.8, 21.6)

The original cart stays the same. Why that happens is covered in mutable vs immutable in Python, and you can document tuple parameters with type hints for tuples.

Once you’re comfortable with this, these guides go a step further:

• Pass a function as a parameter in Python
• How to create a tuple in Python
• Working with a tuple of tuples in Python
• Use pass in a Python function

Frequently asked questions