Chapter 3: Advanced Lists

Teaching Objectives

By the end of this chapter, students should:

• Understand list comprehensions and their advantages
• Master nested list comprehensions
• Learn advanced list operations and methods
• Understand list slicing in depth
• Apply these concepts to solve complex problems efficiently

Preparation

Before teaching this chapter, ensure:

• Students have a solid understanding of basic list operations
• You have prepared examples that demonstrate the power of list comprehensions
• You have real-world examples ready to show when these techniques are useful

Lesson Overview

1. Introduction to List Comprehensions (20 minutes)

Start by explaining list comprehensions:

• List comprehensions provide a concise way to create lists
• They follow the mathematical set-builder notation
• They replace traditional loops for creating lists

Traditional approach vs. List comprehension:

# Traditional approach using a for loop
squares_traditional = []
for i in range(10):
    squares_traditional.append(i**2)
print("Traditional:", squares_traditional)

# Equivalent list comprehension
squares_comprehension = [i**2 for i in range(10)]
print("Comprehension:", squares_comprehension)

Teaching points:

• List comprehensions are more concise and often more readable
• They're generally faster than equivalent for loops
• The basic syntax is: [expression for item in iterable]

More examples:

# Creating a list of even numbers
evens = [x for x in range(20) if x % 2 == 0]
print("Even numbers:", evens)

# Converting strings to uppercase
fruits = ["apple", "banana", "cherry", "date"]
uppercase_fruits = [fruit.upper() for fruit in fruits]
print("Uppercase fruits:", uppercase_fruits)

# Creating a list of tuples
coordinates = [(x, y) for x in range(3) for y in range(3)]
print("Coordinates:", coordinates)

2. Conditional List Comprehensions (15 minutes)

Explain how to incorporate conditionals:

# List comprehension with a condition
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print("Squares of even numbers:", even_squares)

# With if-else condition
numbers = [-5, -3, 0, 3, 5, 8]
signs = ["positive" if x > 0 else "zero" if x == 0 else "negative" for x in numbers]
print("Signs:", signs)

# Filtering out None values
data = [1, None, 3, None, 5]
filtered = [x for x in data if x is not None]
print("Filtered data:", filtered)

Teaching points:

• The if condition at the end filters items from the original iterable
• The if-else in the expression transforms the values
• Be careful with the syntax differences between filtering and transforming

3. Nested List Comprehensions (20 minutes)

Introduce the concept of nesting:

# Flattening a 2D list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print("Flattened matrix:", flattened)

# Creating a matrix (2D list)
matrix = [[i * j for j in range(1, 6)] for i in range(1, 6)]
print("Matrix:")
for row in matrix:
    print(row)

# Filtering in nested list comprehensions
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
even_numbers = [num for row in matrix for num in row if num % 2 == 0]
print("Even numbers from matrix:", even_numbers)

Teaching points:

• Nested comprehensions read from left to right, with outer loops first
• They can be challenging to read, so use them judiciously
• For very complex cases, regular nested loops might be more readable

Visual breakdown: For the matrix creation example, explain how it works step by step:

1. The outer comprehension creates the rows
2. The inner comprehension creates the elements in each row
3. The result is a list of lists (a matrix)

4. Advanced List Operations (25 minutes)

Dive into more advanced list techniques:

Zipping lists:

names = ["Alice", "Bob", "Charlie"]
ages = [24, 32, 28]
heights = [165, 180, 175]

# Combine multiple lists into a list of tuples
people = list(zip(names, ages, heights))
print("People:", people)  # [('Alice', 24, 165), ('Bob', 32, 180), ('Charlie', 28, 175)]

# Unzipping a list of tuples
names2, ages2, heights2 = zip(*people)
print("Unzipped names:", names2)  # ('Alice', 'Bob', 'Charlie')

List unpacking:

# Assign multiple variables at once
first, *middle, last = [1, 2, 3, 4, 5]
print("First:", first)    # 1
print("Middle:", middle)  # [2, 3, 4]
print("Last:", last)      # 5

# Merging lists
part1 = [1, 2, 3]
part2 = [4, 5, 6]
merged = [*part1, *part2]
print("Merged:", merged)  # [1, 2, 3, 4, 5, 6]

Sorting with custom keys:

# Sorting by a specific attribute
students = [
    {"name": "Alice", "grade": 85},
    {"name": "Bob", "grade": 92},
    {"name": "Charlie", "grade": 78}
]

# Sort by grade (highest first)
sorted_by_grade = sorted(students, key=lambda x: x["grade"], reverse=True)
print("Sorted by grade:")
for student in sorted_by_grade:
    print(f"{student['name']}: {student['grade']}")

# Sort by name length, then alphabetically
words = ["apple", "zoo", "banana", "kiwi", "grape"]
sorted_words = sorted(words, key=lambda x: (len(x), x))
print("Sorted words:", sorted_words)

Teaching points:

• zip() is useful for combining multiple lists
• List unpacking with * provides flexibility in assignments
• Custom sorting with key allows for complex sorting logic

5. Advanced List Slicing (15 minutes)

Expand on basic slicing techniques:

numbers = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Basic slicing (start:stop:step)
print("First five:", numbers[:5])       # [0, 1, 2, 3, 4]
print("Last five:", numbers[-5:])       # [5, 6, 7, 8, 9]
print("Every other:", numbers[::2])     # [0, 2, 4, 6, 8]
print("Reversed:", numbers[::-1])       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# Advanced slicing techniques
print("Middle section:", numbers[3:7])  # [3, 4, 5, 6]
print("Skip by 3:", numbers[::3])       # [0, 3, 6, 9]
print("Last 3 reversed:", numbers[-3:][::-1])  # [9, 8, 7]

Teaching points:

• Negative indices count from the end of the list
• The step parameter can be negative to reverse direction
• Slices can be chained for complex operations
• Slices create new lists (they don't modify the original)

Slice assignment:

# Replacing a section of a list
letters = ['a', 'b', 'c', 'd', 'e', 'f']
letters[1:4] = ['B', 'C', 'D']
print("After slice assignment:", letters)  # ['a', 'B', 'C', 'D', 'e', 'f']

# Extending by slice assignment
numbers = [1, 2, 3]
numbers[len(numbers):] = [4, 5, 6]
print("Extended:", numbers)  # [1, 2, 3, 4, 5, 6]

# Removing elements
letters = ['a', 'b', 'c', 'd', 'e', 'f']
letters[1:3] = []
print("After removal:", letters)  # ['a', 'd', 'e', 'f']

6. Memory-Efficient List Processing (15 minutes)

Discuss generators and memory efficiency:

import sys

# Compare memory usage of a list vs a generator expression
numbers_list = [x for x in range(1000000)]
numbers_gen = (x for x in range(1000000))  # Note the parentheses instead of brackets

print("List size (bytes):", sys.getsizeof(numbers_list))
print("Generator size (bytes):", sys.getsizeof(numbers_gen))

# Using generator expressions for memory efficiency
first_5_squares = sum(x**2 for x in range(5))
print("Sum of first 5 squares:", first_5_squares)

# Processing large lists in chunks
def process_in_chunks(large_list, chunk_size=1000):
    for i in range(0, len(large_list), chunk_size):
        chunk = large_list[i:i + chunk_size]
        # Process the chunk
        yield sum(chunk)  # Example: sum each chunk

large_list = list(range(10000))
chunk_sums = list(process_in_chunks(large_list))
print("Number of chunks:", len(chunk_sums))
print("First few chunk sums:", chunk_sums[:5])

Teaching points:

• Generator expressions are similar to list comprehensions but use parentheses
• They generate values on-demand rather than storing the entire list
• This makes them much more memory-efficient for large data sets
• Processing large lists in chunks can help manage memory usage

7. Guided Practice (20 minutes)

Have students work through these exercises:

1. Advanced filtering:

   # Filter and transform a list of dictionaries
   products = [
       {"name": "Laptop", "price": 999, "in_stock": True},
       {"name": "Phone", "price": 599, "in_stock": True},
       {"name": "Tablet", "price": 299, "in_stock": False},
       {"name": "Monitor", "price": 499, "in_stock": True},
       {"name": "Keyboard", "price": 79, "in_stock": True}
   ]
   
   # Get names of available products under $500
   affordable_products = [p["name"] for p in products if p["in_stock"] and p["price"] < 500]
   print("Affordable available products:", affordable_products)
   
   # Calculate total value of in-stock inventory
   inventory_value = sum(p["price"] for p in products if p["in_stock"])
   print("Total inventory value:", inventory_value)
   

2. Matrix operations:

   # Create a matrix
   matrix_a = [
       [1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]
   ]
   
   # Transpose the matrix (rows become columns)
   transposed = [[row[i] for row in matrix_a] for i in range(len(matrix_a[0]))]
   print("Transposed matrix:")
   for row in transposed:
       print(row)
   
   # Create another matrix
   matrix_b = [
       [9, 8, 7],
       [6, 5, 4],
       [3, 2, 1]
   ]
   
   # Add the matrices (element-wise addition)
   matrix_sum = [[matrix_a[i][j] + matrix_b[i][j] 
                 for j in range(len(matrix_a[0]))]
                 for i in range(len(matrix_a))]
   print("Matrix sum:")
   for row in matrix_sum:
       print(row)
   

8. Problem-Solving Activities (15 minutes)

Present students with more challenging problems:

1. Advanced data processing:

   # Data analysis with list comprehensions
   data = [
       {"city": "New York", "temp": [15, 20, 22, 19, 18]},
       {"city": "Los Angeles", "temp": [25, 28, 30, 27, 26]},
       {"city": "Chicago", "temp": [10, 12, 8, 11, 9]}
   ]
   
   # Calculate average temperature for each city
   avg_temps = [(city["city"], sum(city["temp"]) / len(city["temp"])) 
                for city in data]
   print("Average temperatures:")
   for city, avg in avg_temps:
       print(f"{city}: {avg:.1f}°C")
   
   # Find cities with at least one day above 25°C
   hot_cities = [city["city"] for city in data if any(t > 25 for t in city["temp"])]
   print("Cities with hot days:", hot_cities)
   
   # Create a new data structure with min and max temperatures
   temp_ranges = [{"city": city["city"], 
                  "min": min(city["temp"]), 
                  "max": max(city["temp"])}
                 for city in data]
   print("Temperature ranges:")
   for city in temp_ranges:
       print(f"{city['city']}: {city['min']}°C to {city['max']}°C")
   

2. Implementing a custom sorting algorithm:

   # Implement a bubble sort using list comprehensions
   def bubble_sort(arr):
       n = len(arr)
       # Each pass through the list
       for i in range(n):
           # Each comparison (with optimized range)
           # After i passes, the last i elements are already sorted
           swapped = False
           for j in range(0, n-i-1):
               if arr[j] > arr[j+1]:
                   arr[j], arr[j+1] = arr[j+1], arr[j]
                   swapped = True
           # If no swaps were made, the list is sorted
           if not swapped:
               break
       return arr
   
   # Test the sort
   unsorted = [64, 34, 25, 12, 22, 11, 90]
   sorted_list = bubble_sort(unsorted.copy())
   print("Original:", unsorted)
   print("Sorted:", sorted_list)
   
   # Compare with Python's built-in sort
   print("Python sorted:", sorted(unsorted))
   

9. Review and Discussion (10 minutes)

• Review the key concepts covered
• Ask students to explain in their own words:
  • What are list comprehensions and when are they useful?
  • How do nested list comprehensions work?
  • What are some advanced list operations they've learned?

Common Challenges and Solutions

• Readability concerns: List comprehensions can become hard to read when complex. Advise breaking them down into multiple steps when necessary.
• Performance misconceptions: Clarify that while list comprehensions are generally faster, the difference is minimal for small lists.
• Nested comprehension confusion: Draw out the structure of nested comprehensions to help visualize how they work.
• Memory usage: Remind students about the difference between lists and generators for large data sets.

Extension Activities

For students who finish early:

• Challenge them to implement a custom filter function using list comprehensions
• Have them explore set and dictionary comprehensions (related to list comprehensions)
• Ask them to solve a complex data transformation problem using the techniques learned

Assessment

Look for these indicators of understanding:

• Students can write list comprehensions correctly
• They can choose appropriate list operations for specific tasks
• They understand memory considerations for large lists
• They can apply these concepts to solve real-world problems

Resources

• Python Documentation on List Comprehensions
• Real Python: List Comprehensions in Python
• Python Tricks: A Buffet of Awesome Python Features