Chapter 1 — Lists & Tuples

The why

Ordered collections are the backbone of real programs. Every app processes lists of data — users, products, messages, prices. Without lists, you'd create a separate variable for each item. With lists, you store, access, and transform collections of data with a single name.

Python has two main sequence types: lists (mutable) and tuples (immutable). Lists are your daily workhorse — you'll use them everywhere. Tuples are for data that shouldn't change — coordinates, database rows, function returns. Master both, and you can model any ordered collection.

Core concepts: Lists at a glance

Lists are ordered, mutable sequences. Click each category to see the methods you'll use daily:

# Creating lists
empty = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, None]
from_range = list(range(5))  # [0, 1, 2, 3, 4]
 
# Accessing elements
fruits = ["apple", "banana", "cherry", "date"]
print(fruits[0])    # 'apple' (first)
print(fruits[-1])   # 'date' (last)
print(fruits[1:3])  # ['banana', 'cherry'] (slice)

fruits = ["apple", "banana"]
 
# Adding
fruits.append("cherry")      # ['apple', 'banana', 'cherry']
fruits.insert(1, "avocado")  # ['apple', 'avocado', 'banana', 'cherry']
fruits.

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
# Basic slicing
print(numbers[2:5])    # [2, 3, 4]
print(numbers

numbers = [3, 1, 4, 1, 5, 9, 2, 6]
 
# sort() — mutates original
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
 
# sorted() — returns new list
original =

fruits = ["apple", "banana", "cherry", "banana"]
 
# Membership
print("banana" in fruits)  # True
print("grape" in fruits

Mutability: the aliasing bug

Lists are mutable — you can change them after creation. This is powerful but causes bugs when two variables point to the same list.

# The aliasing bug
a = [1, 2, 3]
b = a           # b points to the SAME list
b.append(4)
print(a)        # [1, 2, 3, 4] — a changed too!

Why? b = a doesn't copy the list. Both a and b point to the same object in memory. Changing b changes a because they're the same list.

Fix: make a copy

a = [1, 2, 3]
b = a[:]        # shallow copy
b.append(4)
print(a)        # [1, 2, 3] — a unchanged

When to copy:

• When passing a list to a function that might modify it
• When you need to modify a list without affecting the original
• When building a new list based on an existing one

Tuples: immutable sequences

Tuples are like lists but immutable — you can't change them after creation.

# Creating tuples
point = (3, 4)
single = (42,)  # trailing comma for single-element tuple
empty = ()
from_list = tuple([1, 2, 3])
 
# Accessing (same as lists)
print(point[

Key differences from lists:

When to use tuples:

• Coordinates: point = (3, 4)
• Database rows: user = (1, "Alice", 30)
• Function returns: return name, age
• Dictionary keys: {(0, 0): "origin"}

Tuple unpacking:

point = (3, 4)
x, y = point
print(x)  # 3
print(y)  # 4
 
# Swap
a, b = 1, 2
a, b =

Real-world usage

Processing CSV data:

# Parse CSV rows into lists
rows = [
    ["Alice", 30, "Engineer"],
    ["Bob", 25, "Designer"],
    ["Charlie", 35, "Manager"],
]
 
# Extract names

Building a shopping cart:

cart = []
 
def add_item(name, price, quantity):
    cart.append({"name": name, "price": price, "quantity": quantity})
 
def total():
    return sum(

Common mistakes

Production notes

Performance: List operations are O(1) for append/pop from end, O(n) for insert/remove at arbitrary positions. For large datasets with frequent insertions, consider collections.deque.

Memory: Lists store references to objects, not copies. A list of 1 million integers stores 1 million references (8 bytes each on 64-bit Python), not the integers themselves.

Thread safety: List operations are not atomic. In multi-threaded code, use threading.Lock or switch to queue.Queue.

Practice: Prove your Mastery

Interview Questions

Summary

• Lists are ordered, mutable sequences. Use [] to create, append() to add, pop() to remove.
• Slicing: list[start:stop:step]. [::-1] reverses, [:] copies.
• sort() mutates in place, sorted() returns new list. Use key= for custom sort.
• Tuples are immutable — use for fixed data (coordinates, DB rows, function returns).
• Aliasing bug: b = a doesn't copy. Use b = a[:] or b = a.copy().

Quick recall

I have a list. I want to…
├── Add to end → append(x)
├── Add at position → insert(i, x)
├── Remove by value → remove(x)
├── Remove by index → pop(i) or del list[i]
├── Sort → sort() or sorted()
├── Find → index(x) or in
├── Copy → list[:] or list.copy()
├── Reverse → reverse() or [::-1]
└── Tuple → (1, 2, 3) — immutable

Self-Check Quiz

Warning: index() raises ValueError if not found. Use in first or try/except.