{"id":1037,"date":"2020-11-11T04:06:14","date_gmt":"2020-11-11T04:06:14","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=1037"},"modified":"2025-03-31T04:22:44","modified_gmt":"2025-03-31T04:22:44","slug":"python-unpacking-tuple","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-basics\/python-unpacking-tuple\/","title":{"rendered":"Python Unpacking Tuple"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how to unpack tuples in Python.<\/p>\n\n\n\n

Reviewing Python tuples #<\/a><\/h2>\n\n\n\n

Python defines a tuple<\/a> using commas (,<\/code>), not parentheses ()<\/code>. For example, the following defines a tuple with two elements:<\/p>\n\n\n

1<\/span>,2<\/span> <\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python uses the parentheses to make the tuple clearer:<\/p>\n\n\n
(1<\/span>, 2<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Python also uses the parentheses to create an empty tuple:<\/p>\n\n\n
()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In addition, you can use the tuple()<\/code> constructor like this:<\/p>\n\n\n
tuple()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To define a tuple with only one element, you still need to use a comma. The following example illustrates how to define a tuple with one element:<\/p>\n\n\n
1<\/span>,<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It’s equivalent to the following:<\/p>\n\n\n
(1<\/span>, )<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
(1<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Unpacking a tuple #<\/a><\/h2>\n\n\n\n
Unpacking a tuple means splitting the tuple’s elements into individual variables<\/a>. For example:<\/p>\n\n\n
x, y = (1<\/span>, 2<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The left side:<\/p>\n\n\n
x, y<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
is a tuple of two variables x<\/code> and y<\/code>.<\/p>\n\n\n\n
The right side is also a tuple of two integers 1<\/code> and 2<\/code>.<\/p>\n\n\n\n
The expression assigns the tuple elements on the right side (1, 2) to each variable on the left side (x, y) based on the relative position of each element.<\/p>\n\n\n\n
In the above example, x<\/code> will take 1<\/code> and y<\/code> will take 2<\/code>.<\/p>\n\n\n\n
See another example:<\/p>\n\n\n
x, y ,z = 10<\/span>, 20<\/span>, 30<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The right side is a tuple of three integers 10<\/code>, 20<\/code>, and 30<\/code>. You can quickly check its type as follows:<\/p>\n\n\n
numbers = 10<\/span>, 20<\/span>, 30<\/span>\nprint(type(numbers))<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
<class<\/span> 'tuple<\/span>'><\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In the above example, the x<\/code>, y<\/code>, and z<\/code> variables will take the values 10<\/code>, 20<\/code>, and 30<\/code> respectively.<\/p>\n\n\n\n
Using unpacking tuple to swap values of two variables #<\/a><\/h2>\n\n\n\n
Traditionally, to swap the values of two variables, you would use a temporary variable like this:<\/p>\n\n\n
x = 10<\/span>\ny = 20<\/span>\n\nprint(f'x={x}<\/span>, y={y}<\/span>'<\/span>)\n\ntmp = x\nx = y\ny = tmp\n\nprint(f'x={x}<\/span>, y={y}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
x=10<\/span>, y=20<\/span>\nx=20<\/span>, y=10<\/span>   <\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In Python, you can use the unpacking tuple syntax to achieve the same result:<\/p>\n\n\n
x = 10<\/span>\ny = 20<\/span>\n\nprint(f'x={x}<\/span>, y={y}<\/span>'<\/span>)\n\nx, y = y, x\n\nprint(f'x={x}<\/span>, y={y}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
x=10<\/span>, y=20<\/span>\nx=20<\/span>, y=10<\/span>  <\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following expression swaps the values of two variables, x and y.<\/p>\n\n\n
x, y = y, x<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this expression, Python evaluates the right-hand side first and then assigns the variable from the left-hand side to the values from the right-hand side.<\/p>\n\n\n\n
ValueError: too many values to unpack #<\/a><\/h2>\n\n\n\n
The following example unpacks the elements of a tuple into variables. However, it’ll result in an error:<\/p>\n\n\n
x, y = 10<\/span>, 20<\/span>, 30<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
ValueError: too many values to unpack (expected 2<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This error is because the right-hand side returns three values while the left-hand side only has two variables.<\/p>\n\n\n\n
To fix this, you can add a _<\/code> variable:<\/p>\n\n\n
x, y, _ = 10<\/span>, 20<\/span>, 30<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The _<\/code> variable is a regular variable in Python. By convention, it’s called a dummy variable.<\/p>\n\n\n\n
Typically, you use the dummy variable to unpack when you don’t care and use its value afterward.<\/p>\n\n\n\n
Extended unpacking using the * operator #<\/a><\/h2>\n\n\n\n
Sometimes, you don’t want to unpack every single item in a tuple. For example, you may want to unpack the first and second elements. In this case, you can use the *<\/code> operator. For example:<\/p>\n\n\n
r, g, *other = (192<\/span>, 210<\/span>, 100<\/span>, 0.5<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
192<\/span>\n210<\/span>\n[100<\/span>, 0.5<\/span>]<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, Python assigns 192<\/code> to r<\/code>, 210<\/code> to g<\/code>. Also, Python packs the remaining elements 100<\/code> and 0.5<\/code> into a list and assigns it to the other<\/code> variable.<\/p>\n\n\n\n
Notice that you can only use the *<\/code> operator once on the left-hand side of an unpacking assignment.<\/p>\n\n\n\n
The following example results in error:<\/p>\n\n\n
x, y, *z, *t = (10<\/span>, 20<\/span>, 30<\/span>, '10:30'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
SyntaxError: two starred expressions in<\/span> assignment<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Using the * operator on the right hand side #<\/a><\/h2>\n\n\n\n
Python allows you to use the *<\/code> operator on the right-hand side. Suppose that you have two tuples:<\/p>\n\n\n
odd_numbers = (1<\/span>, 3<\/span>, 5<\/span>)\neven_numbers = (2<\/span>, 4<\/span>, 6<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following example uses the *<\/code> operator to unpack those tuples and merge them into a single tuple:<\/p>\n\n\n
odd_numbers = (1<\/span>, 3<\/span>, 5<\/span>)\neven_numbers = (2<\/span>, 4<\/span>, 6<\/span>)\n\nnumbers = (*odd_numbers, *even_numbers)\nprint(numbers)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
(1<\/span>, 3<\/span>, 5<\/span>, 2<\/span>, 4<\/span>, 6<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Note that the following is an integer<\/a>, not a tuple:<\/p>\n\n\n