Difference between List and Tuple in Python

In Python, both lists and tuples are used to store collections of items, and any type of object can be stored in tuples and lists. However, there are differences between tuples and lists. If you are interested in learning the key difference between a list and a tuple, continue reading this blog, where we explain the list and tuple difference in python in factors of mutability, syntax, performance, usage and available operations.

What is a List?

In python, the list is a collection of ordered mutable items, which are the most powerful and flexible containers in Python. They are built-in data types, which can contain any data format like strings, numbers, lists and objects. In order to define a list in coding, you need to separate items by using coding in an enclosed bracket [ ].

Here is an example of a list of different data types (strings, integers, a nested list within a string) in python:
my_list = [1, 2, 3, “hello”, [4, 5, 6]]

The elements of a list can be accessed and modified using indexing and slicing, and to access the first element, it has an index of 0.

What is a Tuple?

A tuple is an ordered immutable sequence of elements and is a sequence data type containing elements of different data types. Once a tuple is created, you cannot edit, add or remove the elements, unlike a list. Tuples are defined by using a comma-separated sequence of elements in parentheses ‘( )’. An index is used to traverse through a tuple. Though you cannot edit in tuples, you can concatenate tuples and create tuples by combining new ones with existing ones.
An example of a tuple is:
my_tuple = (1, 2, 3, “hello”, (4, 5, 6))

Offensive Hacking Unfolded – Become a Pro Pentester in 2023!

Last Updated: 2023-02-01

4 (165 views)

Gain the ability to perform professional penetration testing and monetize your valuable ethical hacking talent easily!

Explore Course

List and Tuple difference:

Mutability:

List	Tuple
Lists are mutable, which means that you can add, remove, or modify items in the list after it has been created	Tuples, are immutable, which means that once a tuple is created, you cannot add, remove, or modify items in it.

Syntax:

List	Tuple
Lists are enclosed in square brackets [ ]	Tuples are enclosed in parentheses ( ).
Eg: my_list = [1, 2, 3, “hello”, [4, 5, 6]]	Eg: my_tuple = (1, 2, 3, “hello”, (4, 5, 6))

Performance:

List	Tuple
Slower than Tuples in certain operations.	Tuples are faster than lists in operations like indexing and iterations.

Usage:

List	Tuple
Lists are typically used for collections of related items where the order matters, and where you may need to add or remove items from the collection.	Tuples are typically used for fixed collections of related items, such as coordinates or dates, where the order and number of items are known in advance.

Iterations:

List	Tuple
Iterations are time-consuming	Iterations in tuples take time.

Arrays:

List	Tuple
Maintained as dynamic arrays that can grow or shrink as per requirement. A memory is allocated to hold a pointer in the element of the list, and new memory is added as new elements are added, and when an element is removed, unused memory may return to the system.	Fixed-sized array, wherein a block of memory is allocated to a tuple large enough to hold all the elements, and once a tuple is created the size cannot be readjusted, so python doesn’t allocate or remove memory for the tuple.

Error Possibility:

List	Tuple
An unexpected change or error is more likely to occur in a list.	As a tuple is immutable, changes and errors don’t occur frequently.

Data Storage:

List	Tuple
Different types of data can be stored, and mathematical operations can be used directly on lists, and their index can be used to access them.	When you are sure of the information for the object’s field, use a tuple. They are immutable, so they are used as keys for dictionaries. To use a list as a key, you need to convert it into a tuple.

Size Comparison:

List	Tuple
Length of a list is variable. Small blocks of memory are allocated.	The length of a tuple is fixed. Large blocks of memory are allocated due to immutability