Sequences: Lists and Tuples

Chapter Structure

5.1 Introduction

A sequence is an ordered collection of values. Python provides several sequence types, including strings, lists and tuples. This chapter focuses especially on lists and tuples and shows how to store, access, modify, search and process collections of data.

5.2 Lists

A list is an ordered collection written with square brackets []. Lists can contain values of the same type or different types, and they can grow or shrink while a program runs.

Creating a List

numbers = [-45, 6, 0, 72, 1543]
print(numbers)

Accessing List Elements

List indexing starts at 0.

numbers = [10, 20, 30, 40, 50]

print(numbers[0])
print(numbers[2])
print(numbers[-1])

Lists Are Mutable

numbers = [10, 20, 30]
numbers[1] = 99
print(numbers)

The chapter emphasizes that list elements can be modified and that lists can also grow and shrink.

Growing a List with +=

values = []

for number in range(1, 6):
    values += [number]

print(values)

5.3 Tuples

A tuple is another sequence type. It is similar to a list for accessing elements, but the tuple itself is immutable.

student = ('Amanda', 'Blue', 98)

print(student[0])
print(student[2])

Tuple Immutability

numbers = (10, 20, 30)

# numbers[0] = 99   # TypeError

Tuples Can Contain Mutable Objects

A tuple can contain a list. The tuple itself remains immutable, but the list inside it can still be modified.

student = ('Amanda', 'Blue', [98, 75, 87])

student[2][1] = 85

print(student)

The source demonstrates this distinction: the tuple structure is unchanged, but its nested list can be modified.

5.4 Unpacking Sequences

Unpacking means assigning the elements of a sequence to separate variables.

student = ('Amanda', [98, 85, 87])

first_name, grades = student

print(first_name)
print(grades)

You can unpack strings, lists, tuples and sequences produced by range(). The number of variables must match the number of elements, otherwise Python raises ValueError.

first, second = 'hi'
print(first, second)

a, b, c = range(10, 40, 10)
print(a, b, c)

5.5 Sequence Slicing

Slicing creates a new sequence containing a selected part of the original sequence. The basic form is:

sequence[start:stop]

The start index is included, but stop is excluded. The original list is not modified by an ordinary slice operation.

numbers = [2, 3, 5, 7, 11, 13, 17, 19]

print(numbers[2:6])
print(numbers[:6])
print(numbers[4:])
print(numbers[::2])

5.6 del Statement

The del statement can delete individual list elements, slices or even a variable.

numbers = list(range(10))

del numbers[-1]
print(numbers)

del numbers[0:2]
print(numbers)

Deleting a Slice

numbers = list(range(10))

del numbers[::2]
print(numbers)

Deleting Everything in a List

numbers = [1, 2, 3]
del numbers[:]
print(numbers)

The source also demonstrates that del numbers removes the variable itself; attempting to use it afterward causes NameError.

5.7 Passing Lists to Functions

Lists are mutable objects. When a list is passed to a function, the function receives a reference to that list. Therefore, modifying its elements inside the function changes the original list.

def modify_elements(items):
    for i in range(len(items)):
        items[i] *= 2

numbers = [10, 3, 7, 1, 9]

modify_elements(numbers)

print(numbers)

5.8 Sorting Lists

Sorting arranges elements into an order, usually ascending or descending.

sort()

numbers = [7, 2, 9, 1, 5]

numbers.sort()
print(numbers)

numbers.sort(reverse=True)
print(numbers)

sorted()

numbers = [7, 2, 9, 1, 5]

ordered = sorted(numbers)

print(ordered)
print(numbers)

5.9 Searching Sequences

Python provides several simple ways to search a sequence.

Using in and not in

colors = ['red', 'green', 'blue']

print('green' in colors)
print('yellow' not in colors)

index()

colors = ['red', 'green', 'blue', 'green']

print(colors.index('green'))

index() returns the position of the first matching element.

count()

colors = ['red', 'green', 'blue', 'green']

print(colors.count('green'))

5.10 Other List Methods

items = [10, 20, 30]

items.append(40)
items.insert(1, 15)
items.remove(30)

print(items)

items.reverse()
print(items)

5.11 Simulating Stacks with Lists

A stack follows LIFO: Last In, First Out. The most recently added item is the first one removed.

stack = []

stack.append('A')
stack.append('B')
stack.append('C')

print(stack.pop())
print(stack.pop())
print(stack)

5.12 List Comprehensions

A list comprehension is a concise way to create a new list from an iterable.

Basic Form

squares = [x ** 2 for x in range(1, 6)]
print(squares)

With a Condition

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

odd_squares = [x ** 2 for x in numbers if x % 2 != 0]

print(odd_squares)

5.13 Generator Expressions

Generator expressions look like list comprehensions, but use parentheses instead of square brackets.

numbers = [10, 3, 7, 1, 9]

squares_of_odds = (x ** 2 for x in numbers if x % 2 != 0)

for value in squares_of_odds:
    print(value, end=' ')

A generator expression produces values on demand instead of creating the complete list immediately. This can reduce memory use when the whole list is not needed at once.

5.14 Filter, Map and Reduce

Functional-style programming provides ways to process collections.

filter()

filter() keeps values for which a function returns True.

def is_odd(x):
    return x % 2 != 0

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

print(list(filter(is_odd, numbers)))

The chapter describes filter() as a higher-order-function capability: functions themselves can be passed as arguments.

map()

map() applies a function to each value.

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

squares = list(map(lambda x: x ** 2, numbers))

print(squares)

reduce()

A reduction processes many values into a single value, such as a total, product, minimum or maximum. Python's functools.reduce() can be used for custom reductions.

from functools import reduce

numbers = [1, 2, 3, 4]

total = reduce(lambda x, y: x + y, numbers)

print(total)

5.15 Other Sequence Processing Functions

Python provides many built-in functions that work with sequences. Common examples include len(), sum(), min(), max(), any(), all() and enumerate().

enumerate()

enumerate() is especially useful when you need both an element and its index.

colors = ['red', 'green', 'blue']

for index, value in enumerate(colors):
    print(index, value)

Sequence Reversal

numbers = [1, 2, 3, 4]

for value in reversed(numbers):
    print(value, end=' ')

Minimum and Maximum

numbers = [10, 3, 7, 1, 9]

print(min(numbers))
print(max(numbers))
print(sum(numbers))

5.16 Two-Dimensional Lists

A two-dimensional list is a list containing other lists. It is useful for representing data arranged in rows and columns, such as a table or matrix. The chapter processes these structures with nested for loops.

grades = [
    [88, 92, 95],
    [76, 85, 90],
    [91, 89, 94]
]

for row in grades:
    for value in row:
        print(value, end=' ')
    print()

Accessing a Specific Cell

print(grades[1][2])

Think of grades[row][column] as: first choose the row, then choose the item inside that row.

5.17 Intro to Data Science: Simulation and Static Visualizations

This chapter moves from simply storing data to visualizing it. It uses Seaborn and Matplotlib to create static bar charts showing the results of a six-sided-die simulation. Seaborn is built on Matplotlib and simplifies many plotting operations.

Die-Roll Simulation

import random

rolls = [random.randrange(1, 7) for _ in range(600)]

frequencies = [
    rolls.count(face)
    for face in range(1, 7)
]

print(frequencies)

For a fair six-sided die, each face should appear approximately one-sixth of the time. With only 600 rolls, frequencies will not be exactly equal. As the number of rolls becomes much larger, the percentages become closer to the expected value of about 16.667% for each face.

Static Bar Chart

import matplotlib.pyplot as plt
import seaborn as sns

faces = list(range(1, 7))

sns.barplot(x=faces, y=frequencies)
plt.title('Die Frequencies')
plt.xlabel('Die Value')
plt.ylabel('Frequency')
plt.show()

The source chapter uses Seaborn and Matplotlib together to develop a static bar plot of die frequencies.

Law of Large Numbers

Command-Line Arguments

The chapter also shows how a script can receive the number of die rolls from the command line through the Standard Library's sys module.

import random
import sys

rolls = [
    random.randrange(1, 7)
    for _ in range(int(sys.argv[1]))
]

For example, running a script with a value such as 600 makes that value available through sys.argv. The chapter notes that command-line arguments arrive as strings, so the roll count is converted with int().

5.17.1 Sample Graphs for 600, 60,000 and 6,000,000 Die Rolls

The chapter compares simulations at three scales. With more rolls, the frequencies and percentages of the six faces become increasingly similar. This is a practical demonstration of probability becoming more stable over many trials.

5.17.2 Visualizing Die-Roll Frequencies and Percentages

A good visualization should make the data easy to understand. The chapter's static visualization includes a title, x-axis label, y-axis label, bars for the die values and frequency/percentage information.

5.18 Wrap-Up

This chapter develops lists and tuples in detail: creating them, accessing elements, modifying lists, slicing sequences, deleting elements, passing collections to functions, sorting and searching, and using list methods.

It also introduces stacks, list comprehensions, generator expressions, filtering and mapping, two-dimensional lists, and static data visualization.

Common Beginner Mistakes

1. Forgetting that list indexing starts at 0.
2. Using an index outside the valid range.
3. Trying to modify a tuple element.
4. Confusing numbers[2:6] with including index 6 — the stop index is excluded.
5. Using del numbers when you only intended to clear the list.
6. Forgetting that passing a mutable list to a function can allow the function to modify the original list.
7. Confusing sort() with sorted().
8. Calling index() for an item that is not present.
9. Using a list comprehension when a generator would be more appropriate for very large data.
10. Mixing up filter, map and reduce.
11. Forgetting the second index when accessing a two-dimensional list.

Remember These Points

Revision Questions

1. What is a sequence?
2. What is the main difference between a list and a tuple?
3. Why are lists called mutable?
4. What does index -1 mean?
5. What happens when an index does not exist?
6. What is sequence slicing?
7. What does del do?
8. Why can a function modify a list passed to it?
9. What is the difference between sort() and sorted()?
10. How do in, index() and count() differ?
11. How can a list simulate a stack?
12. What is a list comprehension?
13. What is a generator expression?
14. Explain filter(), map() and reduce().
15. What is a two-dimensional list?
16. What does the law of large numbers demonstrate in the die-roll simulation?

Practice Programs

Teaching note: This HTML is a beginner-friendly transformative explanation based on the chapter's concepts and structure. It is designed for learning and revision rather than reproducing the book's original text.