Python Lists
The Workhorse of Every Program

# Example 1: an empty list
empty = []
print(empty, type(empty))

# Example 2: a list literal with mixed types
mixed = ["Glenn", 30, 5.9, True]
print(mixed)

# Example 3: list() constructor from a range
numbers = list(range(1, 6))
print(numbers)

# Example 4: list() constructor from a string
letters = list("python")
print(letters)

# Example 5: a list containing another list (nested)
nested = [1, [2, 3], "four"]
print(nested)

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

# Example 6: positive indexing
print(fruits[0])

# Example 7: negative indexing (last item)
print(fruits[-1])

# Example 8: modifying an element by index (mutability!)
fruits[1] = "blueberry"
print(fruits)

# Example 9: IndexError when the index doesn't exist
try:
    print(fruits[10])
except IndexError as e:
    print(f"Error: {e}")

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

# Example 10: basic slice [start:stop]
print(nums[2:5])

# Example 11: omitting start (from the beginning)
print(nums[:4])

# Example 12: omitting stop (to the end)
print(nums[7:])

# Example 13: step — every second element
print(nums[::2])

# Example 14: reversing a list with a negative step
print(nums[::-1])

# Example 15: the SAME list object changes across calls
scores = [80, 90]
original_id = id(scores)
scores.append(100)
print(scores, id(scores) == original_id)

# Example 16: two names pointing to the same list (aliasing)
a = [1, 2, 3]
b = a
b.append(4)
print("a:", a)
print("b:", b)

# Example 17: contrast with immutable strings
name = "glenn"
name_id = id(name)
name = name.upper()
print(name, id(name) == name_id)

queue = ["Ana", "Bob"]

# Example 18: append() adds ONE item to the end
queue.append("Cara")
print(queue)

# Example 19: extend() adds EACH item from another iterable
queue.extend(["Dara", "Eli"])
print(queue)

# Example 20: the append() vs extend() trap
wrong = ["Ana"]
wrong.append(["Bob", "Cara"])   # adds the WHOLE list as one item
print("append with a list:", wrong)

# Example 21: insert() places an item at a specific index
queue.insert(0, "VIP")
print(queue)

cart = ["pen", "notebook", "eraser", "pen"]

# Example 22: remove() deletes the FIRST matching value
cart.remove("pen")
print(cart)

# Example 23: pop() removes and RETURNS an item (default: last)
last_item = cart.pop()
print("popped:", last_item, "| remaining:", cart)

# Example 24: pop(index) removes from a specific position
first_item = cart.pop(0)
print("popped:", first_item, "| remaining:", cart)

# Example 25: del and clear() for bulk / index-based removal
nums = [10, 20, 30, 40, 50]
del nums[1]         # removes index 1 (value 20)
print("after del:", nums)
nums.clear()        # empties the list entirely
print("after clear:", nums)

inventory = ["sword", "shield", "potion", "potion", "bow"]

# Example 26: index() finds the position of the first match
print(inventory.index("potion"))

# Example 27: count() tallies how many times a value appears
print(inventory.count("potion"))

# Example 28: 'in' for a fast True/False membership check
print("bow" in inventory)
print("axe" in inventory)

scores = [88, 95, 72, 100, 61]

# Example 29: sort() rearranges the list IN PLACE (returns None)
scores.sort()
print(scores)

# Example 30: sorted() returns a NEW list, original untouched
words = ["banana", "Apple", "cherry"]
result = sorted(words)
print("sorted result:", result)
print("original words:", words)

# Example 31: reverse=True for descending order
print(sorted(scores, reverse=True))

# Example 32: key= for custom sort logic (case-insensitive)
print(sorted(words, key=str.lower))

# Example 33: key= with a lambda, sorting objects by an attribute
students = [{"name": "Bob", "gpa": 3.4}, {"name": "Ana", "gpa": 3.9}]
top_first = sorted(students, key=lambda s: s["gpa"], reverse=True)
print(top_first)

import copy

# Example 34: .copy() makes a shallow, independent top-level copy
original = [1, 2, 3]
shallow = original.copy()
shallow.append(4)
print("original:", original)
print("shallow:", shallow)

# Example 35: slicing [:] is an equivalent way to shallow-copy
also_shallow = original[:]
print(also_shallow is original)

# Example 36: shallow copy still shares NESTED objects
matrix = [[1, 2], [3, 4]]
shallow_matrix = matrix.copy()
shallow_matrix[0][0] = 99         # mutates the SHARED inner list
print("matrix affected too:", matrix)

deep_matrix = copy.deepcopy(matrix)
deep_matrix[0][0] = 0
print("matrix NOT affected:", matrix)

# Example 37: the loop way (for comparison)
squares_loop = []
for n in range(6):
    squares_loop.append(n ** 2)
print(squares_loop)

# Example 38: the same result as a comprehension
squares_comp = [n ** 2 for n in range(6)]
print(squares_comp)

# Example 39: comprehension with a filter condition
evens = [n for n in range(20) if n % 2 == 0]
print(evens)

# Example 40: transforming an existing list of strings
names = ["ana", "bob", "cara"]
titled = [name.title() for name in names]
print(titled)

# Example 41: nested loop inside a comprehension (Cartesian product)
pairs = [(x, y) for x in range(3) for y in range(2)]
print(pairs)

# Example 42: if/else INSIDE the expression (ternary, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(6)]
print(labels)

# Example 43: calling a function inside a comprehension
def celsius_to_fahrenheit(c):
    return c * 9/5 + 32

celsius_readings = [0, 20, 37, 100]
fahrenheit_readings = [celsius_to_fahrenheit(c) for c in celsius_readings]
print(fahrenheit_readings)

# Example 44: a 3x3 matrix as a list of lists
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("row 1:", matrix[1])
print("element at row 1, col 2:", matrix[1][2])

# Example 45: iterating over a nested structure
for row in matrix:
    for value in row:
        print(value, end=" ")
print()

# Example 46: transposing a matrix with a nested comprehension
transposed = [[row[i] for row in matrix] for i in range(3)]
print("transposed:", transposed)

# Example 47: basic unpacking — count must match exactly
coordinates = [10, 20, 30]
x, y, z = coordinates
print(x, y, z)

# Example 48: star-unpacking to capture "the rest"
scores = [100, 85, 90, 76, 88]
highest, *remaining = scores
print("highest:", highest, "| remaining:", remaining)

# Example 49: unpacking first, middle, and last simultaneously
first, *middle, last = scores
print("first:", first, "middle:", middle, "last:", last)

players = ["Ana", "Bob", "Cara"]
scores = [95, 88, 76]

# Example 50: enumerate() gives (index, value) pairs
for i, player in enumerate(players):
    print(f"{i}: {player}")

# Example 51: enumerate(start=1) to begin counting from 1
for rank, player in enumerate(players, start=1):
    print(f"Rank {rank}: {player}")

# Example 52: zip() pairs up TWO lists element by element
for player, score in zip(players, scores):
    print(f"{player} scored {score}")

grades = [88, 92, 76, 95, 60, 84]

# Example 53: sum() — total of all numeric items
print("total:", sum(grades))

# Example 54: len() — how many items
print("count:", len(grades))

# Example 55: combining sum() and len() for an average
average = sum(grades) / len(grades)
print(f"average: {average:.1f}")

# Example 56: min() and max() — smallest and largest
print("lowest:", min(grades), "| highest:", max(grades))

# Example 57: any() — True if AT LEAST ONE item is truthy
print("any failing (<70)?", any(g < 70 for g in grades))

# Example 58: all() — True only if EVERY item is truthy
print("all passing (>=60)?", all(g >= 60 for g in grades))

# Example 59: passing a list into a function shares the reference
def add_tax(prices):
    for i in range(len(prices)):
        prices[i] = round(prices[i] * 1.12, 2)

cart = [10.00, 25.00, 5.00]
add_tax(cart)
print("cart mutated by the function:", cart)

# Example 60: the infamous mutable default argument bug
def add_item_bad(item, basket=[]):
    basket.append(item)
    return basket

print(add_item_bad("apple"))
print(add_item_bad("banana"))   # the SAME list is reused across calls!

# Example 61: the correct, safe pattern
def add_item_good(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add_item_good("apple"))
print(add_item_good("banana"))

import sys, time

# Example 62: memory footprint — tuples are lighter than lists
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
print("list bytes:", sys.getsizeof(my_list))
print("tuple bytes:", sys.getsizeof(my_tuple))

# Example 63: membership speed — set vs list on a larger dataset
big_list = list(range(100000))
big_set  = set(big_list)

start = time.perf_counter()
found_in_list = 99999 in big_list
list_time = time.perf_counter() - start

start = time.perf_counter()
found_in_set = 99999 in big_set
set_time = time.perf_counter() - start

print(f"list search: {list_time:.6f}s")
print(f"set search:  {set_time:.6f}s")

# Example 64: converting between the three types
data = [3, 1, 2, 3, 1]
as_tuple = tuple(data)       # now immutable
as_set   = set(data)         # now unique, unordered
print("tuple:", as_tuple, "| set:", as_set)

from collections import deque

# Example 65: a list as a STACK (Last-In, First-Out)
stack = []
stack.append("page1")
stack.append("page2")
stack.append("page3")
print("go back to:", stack.pop())   # page3 — the most recent

# Example 66: a list as a (slow) QUEUE (First-In, First-Out)
queue_as_list = ["Ana", "Bob", "Cara"]
next_customer = queue_as_list.pop(0)   # O(n) — shifts everyone left
print("serving:", next_customer)

# Example 67: the efficient alternative — deque for queues
queue_as_deque = deque(["Ana", "Bob", "Cara"])
next_customer2 = queue_as_deque.popleft()  # O(1)
print("serving:", next_customer2, "| remaining:", list(queue_as_deque))

import time

n = 200000

# Example 68: explicit loop with append()
start = time.perf_counter()
result_loop = []
for i in range(n):
    result_loop.append(i * 2)
loop_time = time.perf_counter() - start

# Example 69: equivalent list comprehension
start = time.perf_counter()
result_comp = [i * 2 for i in range(n)]
comp_time = time.perf_counter() - start

print(f"loop:          {loop_time:.4f}s")
print(f"comprehension: {comp_time:.4f}s")
print("results equal:", result_loop == result_comp)

# Example 70: pre-allocating vs growing — list multiplication for fixed size
fixed_size = [0] * 5
print("pre-sized list:", fixed_size)

tasks = []

def add_task(description):
    tasks.append({"description": description, "done": False})

def complete_task(index):
    if 0 <= index < len(tasks):
        tasks[index]["done"] = True

def show_tasks():
    for i, task in enumerate(tasks):
        status = "✓" if task["done"] else " "
        print(f"[{status}] {i}. {task['description']}")

add_task("Write the lists tutorial")
add_task("Fix the Pyodide indentation bug")
add_task("Publish to Poetic Bytes")
complete_task(1)

show_tasks()

pending = [t["description"] for t in tasks if not t["done"]]
print("\nStill pending:", pending)

gradebook = {
    "Ana": [88, 92, 95],
    "Bob": [72, 68, 74],
    "Cara": [100, 98, 96],
}

def average(scores):
    return sum(scores) / len(scores)

report = sorted(
    [(name, average(scores)) for name, scores in gradebook.items()],
    key=lambda pair: pair[1],
    reverse=True
)

print("Class ranking (highest average first):")
for rank, (name, avg) in enumerate(report, start=1):
    print(f"  {rank}. {name}: {avg:.1f}")

class_average = sum(avg for _, avg in report) / len(report)
print(f"\nOverall class average: {class_average:.1f}")

honor_roll = [name for name, avg in report if avg >= 90]
print("Honor roll:", honor_roll)

def add_matrices(a, b):
    return [
        [a[row][col] + b[row][col] for col in range(len(a[0]))]
        for row in range(len(a))
    ]

def transpose(m):
    return [[row[i] for row in m] for i in range(len(m[0]))]

def flatten(m):
    return [value for row in m for value in row]

matrix_a = [[1, 2], [3, 4]]
matrix_b = [[10, 20], [30, 40]]

print("sum:", add_matrices(matrix_a, matrix_b))
print("transposed A:", transpose(matrix_a))
print("flattened A:", flatten(matrix_a))