Python Lists & Tuples · Storing Collections of Data

• 1. What is a list?
• 2. List operations and methods
• 3. What is a tuple?
• 4. Tuple operations
• 5. List vs Tuple - When to use which?
• 6. Looping through collections
• 7. Quick reference
• 8. Quick Challenge: Spot the Collection
• 9. Exercises
• 10. Common Errors & Solutions
• 11. Check Your Understanding
• 12. Your Progress Tracker

A list is a collection that can hold multiple items. Lists are mutable (you can change, add, or remove items). They are created using square brackets [ ].

# List examples
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]   # Lists can mix types!
empty = []

print(fruits)    # ['apple', 'banana', 'cherry']
print(fruits[0]) # 'apple' (first item)

# Creating a list
colors = ["red", "green", "blue"]

# Accessing elements (indexing starts at 0!)
print(colors[0])    # "red"
print(colors[-1])   # "blue" (negative counts from end)

# Slicing (getting a portion)
print(colors[0:2])  # ['red', 'green'] (up to but not including index 2)

# Changing elements (mutable!)
colors[1] = "yellow"
print(colors)       # ['red', 'yellow', 'blue']

# Adding elements
colors.append("purple")     # add to end
colors.insert(1, "orange")  # insert at position 1

# Removing elements
colors.remove("yellow")     # remove by value
last = colors.pop()         # remove and return last element
colors.pop(1)               # remove element at index 1

# Other useful methods
numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()              # [1, 1, 3, 4, 5, 9]
numbers.reverse()           # reverse order
numbers.count(1)            # 2 (how many times 1 appears)
numbers.index(4)            # 3 (position of first 4)
len(numbers)                # length of list

# Check if element exists
fruits = ["apple", "banana", "cherry"]
if "apple" in fruits:
    print("Found apple!")

A tuple is similar to a list, but it is immutable (cannot be changed after creation). Tuples are created using parentheses ( ).

# Tuple examples
colors = ("red", "green", "blue")
numbers = (1, 2, 3, 4, 5)
single_item = (42,)   # Note: comma is needed for single-item tuple!
empty = ()

# Accessing elements (same as lists)
print(colors[0])    # "red"
print(colors[-1])   # "blue"

# Slicing works too
print(colors[0:2])  # ('red', 'green')

# Tuples are faster and use less memory than lists
# BUT you CANNOT change them:
# colors[0] = "yellow"  # ERROR! Tuples are immutable

# Creating tuples
point = (10, 20)
coordinates = (x, y, z)

# Accessing elements (read-only!)
print(point[0])   # 10

# Concatenation (creates a NEW tuple)
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = t1 + t2      # (1, 2, 3, 4, 5, 6)

# Repetition
t4 = (1, 2) * 3   # (1, 2, 1, 2, 1, 2)

# Tuple methods (only two!)
t = (1, 2, 3, 2, 4, 2)
t.count(2)        # 3 (how many times 2 appears)
t.index(3)        # 2 (position of first 3)

# Check if element exists
if 10 in point:
    print("Found 10!")

# length
len(t)            # 6

# Converting between list and tuple
my_list = [1, 2, 3]
my_tuple = tuple(my_list)     # (1, 2, 3)
back_to_list = list(my_tuple) # [1, 2, 3]

# Tuple unpacking (very useful!)
coordinates = (100, 200)
x, y = coordinates   # x=100, y=200

# When to use list:
scores = [85, 92, 78]     # scores may change
scores.append(95)          # OK to add new scores

# When to use tuple:
days = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")  # fixed
rgb_color = (255, 128, 0)  # fixed color value
player_position = (x, y)   # coordinates that shouldn't change accidentally

# For loop with list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# For loop with tuple
colors = ("red", "green", "blue")
for color in colors:
    print(color)

# Loop with index (using range and len)
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# Using enumerate (get both index and value) - BEST way!
for i, fruit in enumerate(fruits):
    print(f"Index {i}: {fruit}")

# List comprehension (create new list from existing) - very powerful!
numbers = [1, 2, 3, 4, 5]
squares = [n * n for n in numbers]   # [1, 4, 9, 16, 25]
even_numbers = [n for n in numbers if n % 2 == 0]  # [2, 4]

# LISTS (mutable - can change)
my_list = [1, 2, 3]           # create
my_list.append(4)             # add to end
my_list.insert(0, 0)          # insert at position
my_list[1] = 10               # change value
my_list.remove(3)             # remove by value
value = my_list.pop()         # remove last
my_list.sort()                # sort ascending
my_list.reverse()             # reverse order
len(my_list)                  # get length
3 in my_list                  # check if exists

# TUPLES (immutable - cannot change)
my_tuple = (1, 2, 3)          # create
my_tuple[1]                   # access (cannot change!)
t1 + t2                       # concatenate (creates new tuple)
t1 * 3                        # repeat
my_tuple.count(2)             # count occurrences
my_tuple.index(2)             # find position
len(my_tuple)                 # get length

# CONVERSIONS
list_to_tuple = tuple(my_list)
tuple_to_list = list(my_tuple)

1. What is the main difference between a list and a tuple?
2. How do you access the first element of a list called items?
3. What method adds an item to the end of a list?
4. What happens if you try to change an element in a tuple?
5. How do you convert a list to a tuple?
6. When should you use a tuple instead of a list?