What is the difference between list and tuple in Python?

The Differences Between List and Tuple in Python

In Python, both lists and tuples are data structures that can store collections of items. However, there are several key differences between the two:

Mutability

The primary difference between lists and tuples is their mutability. Lists are mutable, meaning you can add, remove, or modify elements within the list after it has been created. In contrast, tuples are immutable, which means that the elements within a tuple cannot be changed once the tuple has been created.

Here's an example to illustrate the difference:

# List
my_list = [1, 2, 3]
my_list[0] = 4  # Modifying an element in the list
print(my_list)  # Output: [4, 2, 3]

# Tuple
my_tuple = (1, 2, 3)
my_tuple[0] = 4  # TypeError: 'tuple' object does not support item assignment

Syntax

Lists are defined using square brackets [], while tuples are defined using parentheses (). For example:

# List
my_list = [1, 2, 3]

# Tuple
my_tuple = (1, 2, 3)

Usage

Lists are generally used when you need to store a collection of items that may need to be modified, added, or removed. Tuples, on the other hand, are often used when you need to store a fixed set of values, such as the coordinates of a point or the dimensions of an image.

Here's an example of how you might use lists and tuples:

# List of names
names = ["Alice", "Bob", "Charlie"]

# Tuple of coordinates
point = (10, 20)

Performance

Tuples are generally faster and more memory-efficient than lists, as they are immutable and don't require the same overhead for dynamic resizing and item insertion/deletion.

Visualization

Here's a Mermaid diagram that summarizes the key differences between lists and tuples:

graph LR A[Data Structure] --> B[List] A --> C[Tuple] B -- Mutable --> D[Can add, remove, or modify elements] C -- Immutable --> E[Cannot change elements after creation] B -- Defined with [] --> F[Example: my_list = [1, 2, 3]] C -- Defined with () --> G[Example: my_tuple = (1, 2, 3)] B -- Used for dynamic collections --> H[Example: list of names] C -- Used for fixed sets of values --> I[Example: tuple of coordinates] B -- Less efficient --> J[Slower and more memory-intensive] C -- More efficient --> K[Faster and more memory-efficient]

In summary, the main differences between lists and tuples in Python are their mutability, syntax, usage, and performance characteristics. Lists are mutable and are often used for dynamic collections, while tuples are immutable and are commonly used for fixed sets of values. Understanding these differences can help you choose the appropriate data structure for your specific needs.