Data Structures: Lists and Tuples

In this module, we will explore two fundamental data structures in Python: Lists and Tuples. These data structures are commonly used to store collections of items. Lists are mutable (modifiable), while Tuples are immutable (non-modifiable). We will cover their characteristics, operations, and use cases.

Subtopic 1: Understanding Lists in Python

A list in Python is an ordered collection of items, which can be of different types. Lists are mutable, meaning their contents can be changed (i.e., items can be added, removed, or updated).

Key Characteristics of Lists:

Ordered: Items in a list have a defined order, and you can access them by index.
Mutable: You can modify a list after it is created.
Can hold multiple data types: Lists can store integers, strings, and even other lists.

Example:

# Creating a list
my_list = [1, 2, 3, "apple", 5.6]

# Accessing list elements
print(my_list[0])  # Output: 1
print(my_list[-1])  # Output: 5.6

# Modifying list elements
my_list[1] = "banana"

# Adding elements
my_list.append("grapes")
my_list.insert(2, "orange")

# Removing elements
my_list.remove("apple")
my_list.pop()

# Slicing
sub_list = my_list[1:3]  # Extract elements from index 1 to 2

# Iterating through a list
for item in my_list:
    print(item)

Subtopic 2: Understanding Tuples in Python

A tuple is an ordered collection of items, similar to a list, but it is immutable. Once a tuple is created, its contents cannot be changed. Tuples are typically used to represent fixed collections of items, such as coordinates or RGB color values.

Key Characteristics of Tuples:

Ordered: Like lists, tuples maintain the order of their elements.
Immutable: After creation, elements of a tuple cannot be modified, added, or removed.
Can hold multiple data types: Tuples can also store various data types.

Example:

# Creating a tuple
my_tuple = (1, 2, 3, "apple", 5.6)

# Accessing tuple elements
print(my_tuple[2])  # Output: 3
print(my_tuple[-1])  # Output: 5.6

# Tuples are immutable, so the following will raise an error:
# my_tuple[1] = "banana"  # TypeError: 'tuple' object does not support item assignment

# Tuple slicing
sub_tuple = my_tuple[1:3]  # Extract elements from index 1 to 2

# Iterating through a tuple
for item in my_tuple:
    print(item)

Subtopic 3: List and Tuple Operations

Both lists and tuples support a variety of operations, but with important differences due to their mutability (lists) and immutability (tuples). Let's go over some common operations for both data structures.

Common List Operations:

Concatenation: Combine two or more lists using the + operator.
Repetition: Repeat the elements of a list using the * operator.
Length: Get the number of elements in a list using len().
Membership: Check if an item exists in the list using the in keyword.
Sorting: Sort the list in place using sort(), or return a new sorted list using sorted().

List Operations Example:

# Concatenation
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2

# Repetition
repeated_list = [1, 2] * 3  # Output: [1, 2, 1, 2, 1, 2]

# Length of the list
print(len(combined_list))  # Output: 6

# Membership check
print(3 in list1)  # Output: True

# Sorting
unsorted_list = [3, 1, 4, 2]
unsorted_list.sort()  # In-place sorting
print(unsorted_list)  # Output: [1, 2, 3, 4]

Common Tuple Operations:

Concatenation: Combine two or more tuples using the + operator.
Repetition: Repeat the elements of a tuple using the * operator.
Length: Get the number of elements in a tuple using len().
Membership: Check if an item exists in the tuple using the in keyword.

Tuple Operations Example:

# Concatenation
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2

# Repetition
repeated_tuple = (1, 2) * 3  # Output: (1, 2, 1, 2, 1, 2)

# Length of the tuple
print(len(combined_tuple))  # Output: 6

# Membership check
print(3 in tuple1)  # Output: True

Subtopic 4: Use Cases for Lists and Tuples

When to Use Lists:

Use a list when you need a collection of items that may change over time (i.e., you may need to add, remove, or modify elements).
Lists are ideal for scenarios where the order of items is important and you expect to modify the list frequently.

Examples of List Use Cases:

Maintaining a dynamic list of students in a class.
Storing user inputs or survey responses that may change or be updated.

When to Use Tuples:

Use a tuple when you need an immutable collection of items that should not be changed after creation.
Tuples are often used for fixed data, such as coordinates, RGB values, or configuration settings.

Examples of Tuple Use Cases:

Representing a coordinate in a 2D space (e.g., (x, y)).
Storing fixed data such as the RGB values for a color (e.g., (255, 0, 0) for red).

Tasks

Task 1: List Operations
- Create a list of your favorite fruits. Add, remove, and modify some of the fruits, and display the list at each step.
Task 2: Tuple Operations
- Create a tuple with five different colors. Try to modify one of the elements (which should raise an error) and print the error message.
Task 3: Slicing
- Given a list of numbers, use slicing to extract a sublist from the middle.
Task 4: Concatenation and Repetition
- Create two lists and concatenate them. Also, repeat a list multiple times and print the result.
Task 5: Tuple Use Case
- Create a tuple to represent the coordinates of a location (latitude, longitude). Then, access the elements and print them with labels.
Task 6: List vs Tuple
- Compare the performance of adding/removing elements in a list versus modifying the elements of a tuple (by creating a new tuple) and explain the results.