List and Tuple have various features and advantages in common, they have significant differences and distinct features that affect their usage, such as mutability, performance, and memory usage. Lists are mutable, which enables us to add, delete, or modify the elements.
The Tuples are immutable, which do not allow modifications or changes. Choosing an appropriate data type between them depends on our needs, whether we want to modify the data or prioritize performance and memory efficiency.
What is a List?
In Python, A List is an ordered, mutable collection of elements. It allows us to perform various modifications such as adding, removing, or changing elements.
Characteristics of Lists:
Here are some of the important features of Python lists:
- Ordered: In this, A List maintains a particular order of its elements with an index starting from 0.
- Mutable: In the Mutable data type, we can edit or make changes to the elements.
- Dynamic:The List can grow or shrink in size dynamically.
- Supports Multiple Data Types:A list can contain elements of various and distinct data types.
- The List uses square brackets ([]) for declaration.
Python List Example
Let us look at an example to create a list in Python.
Example
# creating a list
tst_lst = [19, 23, 10, "pythonapp", 7.8]
# printing the list
print("Initialized list:", tst_lst)
print("Data Type:", type(tst_lst))Output:
Initialized list: [19, 23, 10, 'pythonapp', 7.8]
Data Type: <class 'list'>Explanation:
In the above example, we have created a list using square brackets [] and printed it. We can observe that the initialized list consists of different data types like integer, string, and float.
What is a Tuple?
A tuple is an ordered, immutable collection of elements, which means that once created, its elements cannot be changed.
Characteristics of Tuples:
Here are some of the features included in Python Tuples:
- Ordered: Like lists, in a Tuple, elements have a specific order and can be accessed via an index.
- Immutable: In the Immutable data type, we cannot edit or make changes to the elements.
- Faster than lists: Since tuples are immutable, Python optimizes their storage and processing.
- Supports Multiple Data Types: A tuple can consist of elements of different types.
- Tuples use parentheses (()) for declaration.
Python Tuple Example
Let us look at an example to create a tuple in Python.
Example
# creating a tuple
tst_tpl = (19, 23, 10, "pythonapp", 7.8)
# printing the tuple
print("Initialized Tuple:", tst_tpl)
print("Data Type:", type(tst_tpl))Output:
Initialized Tuple: (19, 23, 10, 'pythonapp', 7.8)
Data Type: <class 'tuple'>
Explanation:
In the above example, we have created a list using parentheses () and printed it. We can observe that the initialized tuple consists of different data types like integer, string, and float. We have printed the data, which is the tuple.
Key Differences between Lists and Tuples
The following are key differences between Lists and Tuples in Python:
| Feature | List | Tuple |
|---|---|---|
| Mutability | We can modify a list by adding or removing items (Mutable). | We cannot modify a tuple by adding or removing items (Immutable). |
| Performance | Lists are slower due to mutability. | Tuples are faster due to their static size and immutability. |
| Memory Usage | List uses more memory. | Tuple uses less memory. |
| Methods | Python List offers more built-in methods. (e.g., append, extend, remove) | Python Tuple offers fewer built-in methods. (e.g., index, count) |
| Syntax | We can define a list using square brackets []. | We can define a tuple using parentheses (). |
| Iteration Speed | Iteration is slightly slower in Lists due to their dynamic nature. | Iteration is faster in Tuples as they are immutable. |
| Storage Efficiency | Lists require extra memory for dynamic allocation. | Tuples are more memory-efficient |
| Error Safety | Lists are prone to accidental changes. | Tuples provide data integrity to prevent errors. |
| Use Case | Lists are used when data needs to change. | Tuples are used when data should remain constant. |
| Example | sample_list = [12, 1, 5, 8, 4] | sample_tuple = (12, 1, 5, 8, 4) |
Mutability Test: Lists vs Tuples
The main difference between List and Tuple is mutability. A list is a mutable data type, meaning that its elements can be changed, added, or removed after initialization.
On the other hand, a Tuple is an immutable data type that cannot be changed after initialization. Any attempt to change an item will result in an error.
Example
# Modifying a list
tst_lst = [14, 23, 39]
print("Given List:", tst_lst)
tst_lst[0] = 17
print("Modified List:", tst_lst)
print()
# Modifying a tuple (Raises an error)
tst_tpl = (14, 23, 39)
print("Given Tuple:", tst_tpl)
tst_tpl[0] = 17 # TypeError: 'tuple' object does not support item assignmentOutput:
Given List: [14, 23, 39]
Modified List: [17, 23, 39]
Given Tuple: (14, 23, 39)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<file-name> n <cell line: 0>()
9 tst_tpl = (14, 23, 39)
10 print("Given Tuple:", tst_tpl)
---> 11 tst_tpl[0] = 17 # TypeError: 'tuple' object does not support item assignment
TypeError: 'tuple' object does not support item assignment
Explanation:
In the above example, we have initialized a list and used indexing to modify its element. As a result, the list is modified successfully. Whereas, in the case of tuples, we have initialized one, but we can observe a returned error when we try modifying it.
Performance and Memory Comparison: Lists vs Tuples
Tuples are generally more memory-efficient and faster than lists. This is because:
- Lists require additional memory allocation for dynamic resizing.
- Tuples are stored in a more optimized way due to their immutability.
Example
import sys
tst_lst = [19, 24, 3, 54, 25]
tst_tpl = (19, 24, 3, 54, 25)
print(sys.getsizeof(tst_lst)) # More memory usage
print(sys.getsizeof(tst_tpl)) # Less memory usageOutput:
104
80
Explanation:
In the above example, we have imported the sys module and initialized a list and a tuple. We have then used the getsizeof() function to return the size of the list and the tuple. As a result, we can observe that the list takes more memory than a tuple.
When to Use Lists?
We can use a list when data needs to be modified dynamically, such as adding/removing elements. The list can be used when we need a sequence with flexible operations. We can use a list while working with large datasets that require updates periodically.
When to Use Tuples?
Tuples are used when data should remain unchanged (e.g., database records, configuration settings). Tuples can be used when performance is the most important factor and critical because tuples are faster and use less memory. Tuples can also be used as dictionary keys, as tuples are hashable, but lists are not.
Conclusion
We have studied a lot about the differences between lists and Tuples. A list is an ordered, mutable collection of elements. It allows us to perform various modifications such as adding, removing, or changing elements, whereas a tuple is an ordered but immutable collection of elements, which means that once created, its elements cannot be changed.
We also learnt about the differences between Lists and tuples with the help of the table, which helped us in recapping the differences in short.
Leave a Reply