Python List Vs Tuple

This tutorial will study the major differences between lists and tuples and how to handle these two data structures.

Lists and tuples are types of data structures that hold one or more than one objects or items in a predefined order. We can contain objects of any data type in a list or tuple, including the null data type defined by the None Keyword.

What is a List?

In other programming languages, list objects are declared similarly to arrays. Lists don’t have to be homogeneous all the time, so they can simultaneously store items of different data types. This makes lists the most useful tool. The list is a kind of container data Structure of Python that is used to hold numerous pieces of data simultaneously. Lists are helpful when we need to iterate over some elements and keep hold of the items.

What is a Tuple?

A tuple is another data structure to store the collection of items of many data types, but unlike mutable lists, tuples are immutable. A tuple, in other words, is a collection of items separated by commas. Because of its static structure, the tuple is more efficient than the list.

Differences between Lists and Tuples

In most cases, lists and tuples are equivalent. However, there are some important differences to be explored in this article.

List and Tuple Syntax Differences

The syntax of a list differs from that of a tuple. Items of a tuple are enclosed by parentheses or curved brackets (), whereas items of a list are enclosed by square brackets [].

Example Code

 # Python code to show the difference between creating a list and a tuple
list_ = [45717]
tuple_ = (41839)
print("List is: ", list_)
print("Tuple is: ", tuple_


List is:  [4, 5, 7, 1, 7]
Tuple is:  (4, 1, 8, 3, 9)

We declared a variable named list_, which contains a certain number of integers ranging from 1 to 10. The list is enclosed in square brackets []. We also created a variable called tuple_, which holds a certain number of integers. The tuple is enclosed in curly brackets (). The type() method in Python returns the data type of the data structure or object passed to it.

Example Code

# Code to print the data type of the data structure using the type() function
print( type(list_) )
print( type(tuple_) )


<class 'list'>
<class 'tuple'>

Mutable List vs. Immutable Tuple

An important difference between a list and a tuple is that lists are mutable, whereas tuples are immutable. What exactly does this imply? It means a list’s items can be changed or modified, whereas a tuple’s items cannot be changed or modified.

We can’t employ a list as a key of a dictionary because it is mutable. This is because a key of a Python dictionary is an immutable object. As a result, tuples can be used as keys to a dictionary if required.

Let’s consider the example highlighting the difference between lists and tuples in immutability and mutability.

Example Code

# Updating the element of list and tuple at a particular index
# creating a list and a tuple
list_ = ["Python""Lists""Tuples""Differences"]
tuple_ = ("Python""Lists""Tuples""Differences")
# modifying the last string in both data structures
list_[3] = "Mutable"
print( list_ )
tuple_[3] = "Immutable"
print( tuple_ )
except TypeError:
print"Tuples cannot be modified because they are immutable" )


['Python', 'Lists', 'Tuples', 'Mutable']
Tuples cannot be modified because they are immutable

We altered the string of list_ at index 3 in the above code, which the Python interpreter updated at index 3 in the output. Also, we tried to modify the last index of the tuple in a try block, but since it raised an error, we got output from the except block. This is because tuples are immutable, and the Python interpreter raised TypeError on modifying the tuple.

Size Difference

Since tuples are immutable, Python allocates bigger chunks of memory with minimal overhead. Python, on the contrary, allots smaller memory chunks for lists. The tuple would therefore have less memory than the list. If we have a huge number of items, this makes tuples a little more memory-efficient than lists.

For example, consider creating a list and a tuple with the identical items and comparing their sizes:

Example Code

# Code to show the difference in the size of a list and a tuple
#creating a list and a tuple
list_ = ["Python""Lists""Tuples""Differences"]
tuple_ = ("Python""Lists""Tuples""Differences")
# printing sizes 
print("Size of tuple: ", tuple_.__sizeof__())
print("Size of list: ", list_.__sizeof__())


Size of tuple:  28
Size of list:  52

Available Functions

Tuples have fewer built-in functions than lists. We may leverage the in-built function dir([object] to access all the corresponding methods for the list and tuple.

Example Code

# printing directory of list


['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Example Code

# Printing directory of a tuple
print( dir(tuple_), end = ", " )


['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

As we can observe, a list has many more methods than a tuple. With intrinsic functions, we can perform insert and pop operations and remove and sort items from the list not provided in the tuple.

Tuples and Lists: Key Similarities

  • They both hold collections of items and are heterogeneous data types, meaning they can contain multiple data types simultaneously.
  • They’re both ordered, which implies the items or objects are maintained in the same order as they were placed until changed manually.
  • Because they’re both sequential data structures, we can iterate through the objects they hold; hence, they are iterables.
  • An integer index, enclosed in square brackets [index], can be used to access objects of both data types.

Leave a Reply

Your email address will not be published. Required fields are marked *