3.11 Difference between List, Set, Tuple, and Dictionary

Python provides four primary built-in collection data types, each serving distinct purposes based on order, mutability, access methods, and typical use cases. Understanding these differences is crucial for efficient and effective Python programming.

Comparison of Python Collection Data Types

This section provides a feature-wise comparison of Python's fundamental collection types: List, Tuple, Set, and Dictionary.

Examples

Here are practical examples illustrating the usage of each collection type:

List

Lists are ordered, mutable sequences that can contain duplicate elements.

# Creating a list
my_list = [10, 20, 30, 20]

# Accessing an element by index
print(f"Accessing element at index 1: {my_list[1]}")
# Output: Accessing element at index 1: 20

# Appending an element
my_list.append(40)
print(f"List after appending 40: {my_list}")
# Output: List after appending 40: [10, 20, 30, 20, 40]

# Updating an element
my_list[0] = 5
print(f"List after updating element at index 0: {my_list}")
# Output: List after updating element at index 0: [5, 20, 30, 20, 40]

Tuple

Tuples are ordered, immutable sequences that can also contain duplicate elements. Once created, their contents cannot be modified.

# Creating a tuple
my_tuple = (10, 20, 30, 20)

# Accessing an element by index
print(f"Accessing element at index 2: {my_tuple[2]}")
# Output: Accessing element at index 2: 30

# Attempting to modify an element (will raise a TypeError)
# my_tuple[1] = 50
# This would raise an error: TypeError: 'tuple' object does not support item assignment

Set

Sets are unordered collections of unique elements. They are mutable, meaning elements can be added or removed, but duplicates are automatically discarded.

# Creating a set
my_set = {10, 20, 30, 20} # Duplicate 20 is ignored

# Checking for membership
print(f"Is 20 in the set? {20 in my_set}")
# Output: Is 20 in the set? True

# Adding an element
my_set.add(40)
print(f"Set after adding 40: {my_set}")
# Output: Set after adding 40: {10, 20, 30, 40} (order may vary)

# Adding a duplicate element (no change)
my_set.add(20)
print(f"Set after adding duplicate 20: {my_set}")
# Output: Set after adding duplicate 20: {10, 20, 30, 40} (order may vary)

Dictionary

Dictionaries are mutable collections that store data in key-value pairs. Keys must be unique and immutable (e.g., strings, numbers, tuples), while values can be any data type and can be duplicated.

# Creating a dictionary
my_dict = {'a': 1, 'b': 2}

# Accessing a value using its key
print(f"Value for key 'a': {my_dict['a']}")
# Output: Value for key 'a': 1

# Adding a new key-value pair
my_dict['c'] = 3
print(f"Dictionary after adding 'c': {my_dict}")
# Output: Dictionary after adding 'c': {'a': 1, 'b': 2, 'c': 3}

# Updating an existing key's value
my_dict['b'] = 20
print(f"Dictionary after updating value for 'b': {my_dict}")
# Output: Dictionary after updating value for 'b': {'a': 1, 'b': 20, 'c': 3}

Summary of Use Cases

• List: Use when you need an ordered, changeable collection that allows duplicate elements, such as a list of user inputs or a sequence of steps.
• Tuple: Use when you want an ordered, unchangeable collection, such as coordinates, configuration settings, or when you want to ensure data integrity.
• Set: Use when you need to store unique items and efficiently perform operations like membership testing, removing duplicates, or finding intersections/unions.
• Dictionary: Use when you need a mapping of keys to values for fast lookups, such as storing configuration parameters, user profiles, or representing relationships.

Potential Interview Questions

• What are the primary differences between lists, tuples, sets, and dictionaries in Python?
• Which Python collection types are mutable and which are immutable? Explain the implications of mutability.
• When would you choose to use a tuple instead of a list, and why?
• How does a set differ from a list in terms of element uniqueness and order?
• Explain how dictionaries store data and the mechanism for accessing elements. What are the requirements for dictionary keys?
• Can dictionary keys be mutable objects like lists? Explain why or why not.
• Describe how the order of elements is handled across these four collection types, considering Python version differences.
• What are some common and practical use cases for sets in Python programming?
• Discuss the performance implications of using lists, tuples, sets, and dictionaries for common operations like element access and membership testing.
• Provide code examples demonstrating how to add and remove elements from each of these collection types.