Chapter 5: Creating Lists

Teaching Objectives

By the end of this chapter, students should:

• Understand what lists are and why they are useful
• Know how to create, access, modify, and manipulate lists
• Master common list operations and methods
• Understand list slicing and its applications
• Apply lists to solve programming problems

Preparation

Before teaching this chapter, ensure:

• Students have a solid understanding of variables, data types, and loops
• You have prepared visual aids to explain list indexing
• You have tested all code examples and prepared sample problem solutions

Lesson Overview

1. Introduction to Lists (15 minutes)

Start by explaining what lists are and why they are important:

• Lists are ordered collections of items
• Items can be of different data types (numbers, strings, even other lists)
• Lists are mutable (can be changed)
• Lists are one of the most commonly used data structures in Python

Analogy: A list is like a train with multiple cars (elements), each carrying different cargo (values). The cars are numbered (indexed) so you can find them easily.

Creating basic lists:

# Empty list
empty_list = []

# List of numbers
numbers = [1, 2, 3, 4, 5]

# List of strings
fruits = ["apple", "banana", "cherry"]

# Mixed data types
mixed = [1, "hello", True, 3.14]

# Nested lists
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Print examples
print(numbers)  # Outputs: [1, 2, 3, 4, 5]
print(fruits)   # Outputs: ['apple', 'banana', 'cherry']
print(mixed)    # Outputs: [1, 'hello', True, 3.14]
print(matrix)   # Outputs: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Teaching points:

• Lists are defined using square brackets []
• Elements are separated by commas
• Lists can store any type of data, including other lists
• The len() function gives the number of elements in a list

2. Accessing List Elements (20 minutes)

Explain how to access individual elements in a list:

fruits = ["apple", "banana", "cherry", "orange", "kiwi"]

# Accessing by index (0-based indexing)
first_fruit = fruits[0]  # "apple"
second_fruit = fruits[1]  # "banana"
print(f"First fruit: {first_fruit}")
print(f"Second fruit: {second_fruit}")

# Negative indexing (counting from the end)
last_fruit = fruits[-1]  # "kiwi"
second_last = fruits[-2]  # "orange"
print(f"Last fruit: {last_fruit}")
print(f"Second last fruit: {second_last}")

Visual representation: Use a diagram showing indexes both from start (0, 1, 2) and end (-1, -2, -3):

 Index:     0        1         2         3        4
 List:   ["apple", "banana", "cherry", "orange", "kiwi"]
 Neg:      -5       -4        -3        -2       -1

Common errors to highlight:

• IndexError when trying to access an index that doesn't exist
• Remember that indexing starts at 0, not 1
• Negative indices start from -1 (not 0)

# This will cause an IndexError
# print(fruits[5])  # Index out of range

# Safe way to access elements with condition
if len(fruits) > 5:
    print(fruits[5])
else:
    print("Index 5 does not exist in the list")

3. Modifying Lists (15 minutes)

Explain how to change list elements:

colors = ["red", "green", "blue"]
print("Original list:", colors)

# Changing a value by index
colors[0] = "yellow"
print("After changing first element:", colors)  # ["yellow", "green", "blue"]

# Adding elements to a list
colors.append("purple")  # Add to the end
print("After append:", colors)  # ["yellow", "green", "blue", "purple"]

colors.insert(1, "orange")  # Insert at specific position
print("After insert:", colors)  # ["yellow", "orange", "green", "blue", "purple"]

# Extending a list with another list
more_colors = ["pink", "black"]
colors.extend(more_colors)
print("After extend:", colors)  # ["yellow", "orange", "green", "blue", "purple", "pink", "black"]

# Remove elements
colors.remove("green")  # Remove by value
print("After remove:", colors)  # ["yellow", "orange", "blue", "purple", "pink", "black"]

popped_color = colors.pop()  # Remove and return the last item
print("Popped value:", popped_color)  # "black"
print("After pop:", colors)  # ["yellow", "orange", "blue", "purple", "pink"]

popped_index = colors.pop(1)  # Remove by index
print("Popped at index 1:", popped_index)  # "orange"
print("After pop with index:", colors)  # ["yellow", "blue", "purple", "pink"]

# Clear all elements
colors.clear()
print("After clear:", colors)  # []

Teaching approach:

• Demonstrate each method with visual examples
• Explain the difference between methods that modify the original list and ones that create a new list
• Highlight that lists are mutable (unlike strings which are immutable)

4. List Operations (15 minutes)

Introduce common operations that can be performed on lists:

# Concatenation
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print("Combined list:", combined)  # [1, 2, 3, 4, 5, 6]

# Repetition
repeated = [0] * 5
print("Repeated list:", repeated)  # [0, 0, 0, 0, 0]

# Check if an element is in a list
fruits = ["apple", "banana", "cherry"]
print("Is 'apple' in fruits?", "apple" in fruits)  # True
print("Is 'mango' in fruits?", "mango" in fruits)  # False

# List length
print("Number of fruits:", len(fruits))  # 3

# Min and max
numbers = [5, 2, 8, 1, 9]
print("Minimum value:", min(numbers))  # 1
print("Maximum value:", max(numbers))  # 9

# Sum
print("Sum of numbers:", sum(numbers))  # 25

Teaching points:

• Lists can be combined using the + operator
• The * operator repeats a list
• The in keyword checks for membership
• Built-in functions like len(), min(), max(), and sum() are very useful with lists

5. List Slicing (20 minutes)

Explain the concept of slicing to access a subset of list elements:

fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

# Basic slicing [start:stop] (stop index not included)
slice1 = fruits[1:4]
print("Slice [1:4]:", slice1)  # ["banana", "cherry", "orange"]

# Omitting start index (defaults to 0)
slice2 = fruits[:3]
print("Slice [:3]:", slice2)  # ["apple", "banana", "cherry"]

# Omitting stop index (defaults to end)
slice3 = fruits[4:]
print("Slice [4:]:", slice3)  # ["kiwi", "melon", "mango"]

# Negative indices in slicing
slice4 = fruits[-3:]
print("Slice [-3:]:", slice4)  # ["kiwi", "melon", "mango"]

# Step parameter [start:stop:step]
slice5 = fruits[0:7:2]
print("Slice [0:7:2]:", slice5)  # ["apple", "cherry", "kiwi", "mango"]

# Negative step (reverse order)
reverse = fruits[::-1]
print("Reverse slice [::-1]:", reverse)  # ["mango", "melon", "kiwi", "orange", "cherry", "banana", "apple"]

Teaching approach:

• Use visual diagrams to show how slicing works
• Emphasize that the start index is inclusive, but the stop index is exclusive
• Show how omitting parameters provides useful defaults
• Demonstrate the power of the step parameter, especially for tasks like reversing a list

6. List Methods (15 minutes)

Introduce more useful list methods:

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# Sorting
numbers.sort()
print("Sorted list:", numbers)  # [1, 1, 2, 3, 4, 5, 5, 6, 9]

# Reversing
numbers.reverse()
print("Reversed list:", numbers)  # [9, 6, 5, 5, 4, 3, 2, 1, 1]

# Counting occurrences
count_of_1 = numbers.count(1)
print("Count of 1:", count_of_1)  # 2

# Finding index of first occurrence
index_of_5 = numbers.index(5)
print("Index of first 5:", index_of_5)  # 2

# Creating sorted copy without modifying original
original = [3, 1, 4, 1, 5]
sorted_copy = sorted(original)
print("Original:", original)  # [3, 1, 4, 1, 5]
print("Sorted copy:", sorted_copy)  # [1, 1, 3, 4, 5]

# Copy a list
original = [1, 2, 3]
copy1 = original.copy()
copy2 = list(original)
copy3 = original[:]  # Slice copy
print("All copies:", copy1, copy2, copy3)  # [1, 2, 3] [1, 2, 3] [1, 2, 3]

Teaching points:

• Distinguish between methods that modify the original list (like sort()) and functions that return a new list (like sorted())
• Explain the importance of copying lists to avoid unintended modifications
• Show how methods can be chained for complex operations

7. Nested Lists and Matrices (15 minutes)

Explain how to work with lists inside lists:

# Creating a 3x3 matrix
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accessing elements in a nested list
print("Element at row 1, column 2:", matrix[1][2])  # 6

# Looping through a matrix
print("Matrix elements:")
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()  # New line after each row
# Outputs:
# 1 2 3
# 4 5 6
# 7 8 9

# Modifying an element in a nested list
matrix[0][1] = 20
print("Modified matrix:", matrix)
# [[1, 20, 3], [4, 5, 6], [7, 8, 9]]

Applications of matrices:

• Game boards (chess, tic-tac-toe)
• Image processing (pixels in rows and columns)
• Spreadsheet data

8. Guided Practice (20 minutes)

Have students work through these exercises:

1. List basics:

   # Create and manipulate a shopping list
   shopping_list = ["milk", "eggs", "bread", "apples"]
   
   # Add an item
   shopping_list.append("cheese")
   
   # Insert an item at position 2
   shopping_list.insert(2, "butter")
   
   # Remove an item
   shopping_list.remove("eggs")
   
   # Sort the list
   shopping_list.sort()
   
   print("Final shopping list:", shopping_list)
   

2. List operations:

   # Calculate average of a list of grades
   grades = [85, 90, 78, 93, 88]
   average = sum(grades) / len(grades)
   print(f"The average grade is: {average:.2f}")
   
   # Find the highest and lowest grades
   highest = max(grades)
   lowest = min(grades)
   print(f"Highest grade: {highest}")
   print(f"Lowest grade: {lowest}")
   

3. List filtering:

   # Filter even numbers from a list
   numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   even_numbers = []
   
   for num in numbers:
       if num % 2 == 0:
           even_numbers.append(num)
   
   print("Even numbers:", even_numbers)
   

9. Problem-Solving Activities (15 minutes)

Present students with more challenging problems:

1. List transformation:

   # Square all numbers in a list
   numbers = [1, 2, 3, 4, 5]
   squared = []
   
   for num in numbers:
       squared.append(num ** 2)
   
   print("Original numbers:", numbers)
   print("Squared numbers:", squared)  # [1, 4, 9, 16, 25]
   

2. Finding common elements:

   # Find common elements in two lists
   list1 = [1, 2, 3, 4, 5]
   list2 = [4, 5, 6, 7, 8]
   common = []
   
   for item in list1:
       if item in list2:
           common.append(item)
   
   print("Common elements:", common)  # [4, 5]
   

3. Removing duplicates:

   # Remove duplicates from a list while preserving order
   original = [1, 2, 2, 3, 4, 3, 5, 1, 6]
   no_duplicates = []
   
   for item in original:
       if item not in no_duplicates:
           no_duplicates.append(item)
   
   print("Original list:", original)
   print("Without duplicates:", no_duplicates)  # [1, 2, 3, 4, 5, 6]
   

10. Review and Discussion (10 minutes)

• Review the key concepts covered
• Ask students to explain in their own words:
  • What is a list and why is it useful?
  • How do you create, access, and modify list elements?
  • What are some common list operations and methods?
  • How does list slicing work?

Common Challenges and Solutions

• Index errors: Remind students to check list lengths before accessing elements, especially with user input.
• Mutable nature: Explain that modifying a list changes it in-place, which can lead to unexpected behavior when copied by reference.
• Nested list complexity: Break down nested list operations step by step, using visual aids.
• List copies vs. references: Clarify the difference between copying a list and creating a reference to the same list.

Extension Activities

For students who finish early:

• Challenge them to create a program that sorts a list of names alphabetically
• Have them implement a simple to-do list application with add, remove, and view functions
• Ask them to create a tic-tac-toe game board using nested lists

Assessment

Look for these indicators of understanding:

• Students can create and manipulate lists correctly
• They understand list indexing and slicing
• They can apply list methods to solve problems
• They can work with nested lists

Resources

• Python Documentation on Lists
• Interactive List Visualization
• List Method Reference