Lists — Creation, Indexing, Methods

empty = []
numbers = [1, 2, 3, 4, 5]
names = ["Maria", "Jordan", "Priya"]
mixed = [1, "two", 3.0, True, None]     # a list can freely mix types

# list() can also build a list from any iterable
letters = list("Python")                  # ['P', 'y', 't', 'h', 'o', 'n']
evens = list(range(0, 10, 2))              # [0, 2, 4, 6, 8]

fruits = ["apple", "banana", "cherry", "date"]

print(fruits[0])     # apple    — first item
print(fruits[-1])     # date      — last item
print(fruits[2])       # cherry    — third item

fruits[1] = "blueberry"   # lists are mutable — items can be reassigned by index
print(fruits)              # ['apple', 'blueberry', 'cherry', 'date']

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

print(numbers[2:5])      # [2, 3, 4]         — indices 2, 3, 4 (5 excluded)
print(numbers[:3])         # [0, 1, 2]          — from the start up to (not including) 3
print(numbers[7:])          # [7, 8, 9]           — from 7 to the end
print(numbers[::2])           # [0, 2, 4, 6, 8]      — every second item
print(numbers[::-1])            # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]  — the whole list, reversed

# Unlike indexing a single out-of-range item, slicing never raises an error
print(numbers[5:100])   # [5, 6, 7, 8, 9]    — just stops at the real end, no IndexError

fruits = ["apple", "banana"]

fruits.append("cherry")          # adds ONE item to the end
print(fruits)                     # ['apple', 'banana', 'cherry']

fruits.insert(1, "apricot")        # inserts at a specific index, shifting the rest right
print(fruits)                       # ['apple', 'apricot', 'banana', 'cherry']

fruits.extend(["date", "fig"])        # adds MULTIPLE items, one at a time, from another iterable
print(fruits)                          # ['apple', 'apricot', 'banana', 'cherry', 'date', 'fig']

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

fruits.remove("banana")     # removes the FIRST matching value — not by index
print(fruits)                 # ['apple', 'cherry', 'banana']

last = fruits.pop()             # removes AND RETURNS the last item by default
print(last)                      # banana
print(fruits)                     # ['apple', 'cherry']

first = fruits.pop(0)               # pop() also accepts an explicit index
print(first)                          # apple

fruits.clear()                          # removes everything
print(fruits)                            # []

numbers = [4, 1, 3, 2]
result = numbers.sort()

print(numbers)   # [1, 2, 3, 4]  — the ORIGINAL list was changed
print(result)      # None          — .sort() does NOT return the sorted list!

numbers = [4, 1, 3, 2]
result = sorted(numbers)

print(numbers)   # [4, 1, 3, 2]  — UNCHANGED
print(result)      # [1, 2, 3, 4]  — a brand new, separate list

words = ["banana", "kiwi", "apple", "fig"]

sorted(words, key=len)                    # ['kiwi', 'fig', 'apple', 'banana'] — sorted by length
sorted(words, reverse=True)                 # ['kiwi', 'fig', 'banana', 'apple'] — Z to A
sorted(words, key=len, reverse=True)          # combined — longest first

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

numbers.reverse()          # reverses the list IN PLACE (not alphabetical/numeric — just order)
print(numbers)                # [6, 2, 9, 5, 1, 4, 1, 3]

print(numbers.index(4))         # 4     — the INDEX of the first "4" found
print(numbers.count(1))           # 2      — how many times "1" appears in the list

# index() raises ValueError if the value isn't present at all — check with "in" first if unsure
if 100 in numbers:
    print(numbers.index(100))
else:
    print("100 is not in the list")

original = [1, 2, 3]
reference = original       # NOT a copy — "reference" points at the SAME list object

reference.append(4)
print(original)               # [1, 2, 3, 4]  — changed too!
print(reference)                # [1, 2, 3, 4]
print(original is reference)      # True — literally the same object in memory

def add_bonus_item(cart):
    cart.append("free_sample")     # mutates the list the CALLER passed in
    return cart

my_cart = ["shirt", "pants"]
result = add_bonus_item(my_cart)

print(my_cart)   # ['shirt', 'pants', 'free_sample']  — the original changed too, even
                    # though we only assigned the function's return value to "result"
print(result)         # ['shirt', 'pants', 'free_sample']
print(my_cart is result)   # True — same list, two names

original = [1, 2, 3]

alias = original            # NOT a copy — same object, two names
copy1 = original.copy()       # a REAL copy — a new list with the same items
copy2 = original[:]             # ALSO a real copy — slicing the whole list

original.append(99)

print(original)   # [1, 2, 3, 99]
print(alias)          # [1, 2, 3, 99]   — changed, because it's the SAME object
print(copy1)             # [1, 2, 3]         — unaffected, genuinely independent
print(copy2)                # [1, 2, 3]         — also unaffected

matrix = [[1, 2], [3, 4]]
shallow = matrix.copy()          # a real copy of the OUTER list...

shallow[0].append(99)              # ...but the INNER lists are still shared!

print(matrix)     # [[1, 2, 99], [3, 4]]   — changed, even though we only touched "shallow"!
print(shallow)       # [[1, 2, 99], [3, 4]]

print(matrix is shallow)                # False — the outer lists are genuinely different objects
print(matrix[0] is shallow[0])            # True  — but the INNER lists are still the same object

import copy

matrix = [[1, 2], [3, 4]]
deep = copy.deepcopy(matrix)     # recursively copies EVERY nested object, not just the outer list

deep[0].append(99)

print(matrix)   # [[1, 2], [3, 4]]        — genuinely unaffected
print(deep)        # [[1, 2, 99], [3, 4]]     — only the deep copy changed

list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_c = list_a

print(list_a == list_b)    # True  — equal CONTENTS, compared item by item
print(list_a is list_b)      # False — two separate objects that happen to hold equal values

print(list_a == list_c)         # True  — also equal contents
print(list_a is list_c)           # True  — AND the same object, since list_c = list_a shares it

A Minneapolis grocery-delivery startup assigns each driver a base route template — a list of standard stops for their zone — which the dispatch system then customises per driver by appending that day's specific delivery stops. One morning, every driver on the app opens their route and sees the exact same twenty-two stops, none of which match their own zone. Dispatch is flooded with confused calls within minutes of the shift starting.

What the engineer finds

The dispatch code builds each driver's route by starting from a shared base_route template and appending stops directly onto it — exactly the Part 04 problem, list assignment creating a shared reference rather than an independent copy.

base_route = ["Warehouse A", "Warehouse B"]   # shared starting template

def build_driver_route(driver, todays_stops):
    route = base_route             # NOT a copy — "route" points at the shared base_route
    route.extend(todays_stops)       # mutates base_route itself, for EVERY driver
    driver.route = route
    return route

for driver in get_active_drivers():
    build_driver_route(driver, get_stops_for(driver))

Every call to build_driver_route appends that driver's stops onto the same shared base_route list, since route = base_route never copied anything. By the time the last driver's route was built, base_route contained every single stop from every driver processed so far — and because every driver object's .route attribute pointed at that same growing list, all of them ended up looking identical, and identical to whichever driver was processed last.

The fix

base_route = ["Warehouse A", "Warehouse B"]

def build_driver_route(driver, todays_stops):
    route = base_route.copy()       # a genuinely independent list per driver
    route.extend(todays_stops)
    driver.route = route
    return route

One added method call — .copy() — fixes the entire incident. The lesson the team takes away, and the one worth internalising from this module generally: any time a "starting point" list is going to be built on by multiple independent callers, ask explicitly whether each caller needs its own copy, because Python will never make one for you silently.