vizlearn

Tuples and Unpacking

PythonBy Updated

A sequence that cannot be changed after it is built, and the syntax that takes one apart in a single line.

Overview

The difference that matters

A list and a tuple both hold an ordered run of items, and both index the same way. The difference is one word: a tuple is immutable. Once it exists, no element can be replaced.

point = (3, 4)
point[0] = 99  # TypeError

That sounds like a limitation and is mostly a guarantee. If you hand a list to a function, the function can change it under you. Hand it a tuple and it cannot.

tuples.py

tuples.py Python 3
Output

                    

                

                

            

            

                
why_tuples.py

                

                

                    
                    

                        why_tuples.py
                        Python 3
                    

                    

                        
                        

                            
                            
                        

                    

                    

                        
                        
                        
                    

                    

                        
Output

                        

                    

                

                

            

            

            

                

                    
Worth knowing

                    

                        
A tuple is written with commas, not brackets. 1, 2 is already a tuple; the brackets only group it.

                        
Immutable means the tuple cannot be re-pointed, so it can be a dict key or a set member. A list cannot.

                        
a, b = b, a builds a tuple on the right, then unpacks it. That is why the swap needs no temporary.

                        
One element needs a trailing comma: (5,). Without it you have brackets round a number.

                    

                

            

        

    

    
    

        


            

                
Tuples and Unpacking: A Practical Guide

                
A tuple is a sequence that cannot be changed once built. That single restriction is what makes it usable as a dictionary key, safe to hand around, and the natural way to return more than one value.

            

            

                
                

                    
Why immutability buys you a dictionary key

                    
A dictionary key has to be hashable, which in practice means it must never change — if it changed, the dictionary would look for it in the wrong place. Lists are mutable, so they are unhashable, so they cannot be keys. Tuples can.
grid[(2, 3)] = "wall"
That is how you key anything by a coordinate pair, a date triple, or any other small fixed group.

                

                

                    
Unpacking is the point

                    
Unpacking assigns each position to a name in one statement:
x, y = point
It is not a special tuple feature — it works on any sequence — but tuples are where you meet it. The number of names must match the number of items, or Python raises ValueError, which is a feature: it catches the case where the shape you expected is not the shape you got.
The swap idiom falls straight out of it:
a, b = b, a
The right-hand side is evaluated first, into a tuple, and only then unpacked. No temporary variable, and no ordering bug.

                

                

                    
Returning more than one thing

                    
Python has no special syntax for multiple return values because it does not need any. return min(xs), max(xs) returns a tuple, and the caller unpacks it:
low, high = min_max(values)
This reads better than returning a list, because the shape is fixed: exactly two things, in a known order.

                

                

                    
The comma is the tuple

                    
The most common surprise is that brackets do not make a tuple — commas do.
type((5))   # int
type((5,))  # tuple
A single-element tuple needs the trailing comma. It looks like a typo and is not. This bites when a function is supposed to return one item as a tuple and quietly returns the item instead.

                

                

                    
When to reach for which

                    
Use a list when the collection will grow, shrink or be sorted in place. Use a tuple when the group is fixed at creation and its positions mean something: a coordinate, an RGB colour, a row from a database. If you find yourself never mutating a list, a tuple states that intent and gets you hashability for free.

                

            


        

    


    



Check yourself
0 of 3
Answer without scrolling back up.
  1. Why can a tuple be a dictionary key when a list cannot?
  2. What is `type((5))`?
  3. In `a, b = b, a`, why is no temporary variable needed?





 Cheat sheet
Tuples and Unpacking
A tuple is a sequence that cannot be changed once built. That single restriction is what makes it usable as a dictionary key, safe to hand around, and the natural way to return more than one value.
PYTHON · vizlearn.in/python/tuples_and_unpacking.html
More in Python
PythonSets and Set OperationsPythonBooleans and ComparisonsPythonIf, Elif and ElsePythontry and except
About the author
Ashish Jangra builds and maintains VizLearn. Every module here is written and the visualisation behind it hand-built, so the numbers in a readout come from the same code that draws the picture. Corrections are genuinely welcome and get priority over everything else — if a page states something wrong, or an animation misrepresents what the algorithm does, get in touch.
About VizLearnGitHubLinkedInContact