Lists & Tuples

Lists & Tuples | Algoryva

First, the naive way

One variable per value

With only single variables you would store three scores as score1, score2, score3 and compare them with an if for each.

It works for three scores. For three hundred you would need three hundred names and three hundred ifs, and the code cannot use a loop because you cannot say “the next variable”. A list lets you say scores[i] and loop over i.

python

score1 = 72
score2 = 90
score3 = 85
best = score1
if score2 > best:
    best = score2
if score3 > best:
    best = score3
print(best)   # 90

Cost: Code length grows with every value, and the code cannot loop over the values.

Worked by hand

Slice rules on a six-item list

For a = [10, 20, 30, 40, 50, 60] the indices are 0 to 5, or -6 to -1.

expression	meaning	result
a[1:4]	indices 1, 2, 3	[20, 30, 40]
a[:3]	from the start up to index 3	[10, 20, 30]
a[-2:]	the last two	[50, 60]
a[::2]	every second item	[10, 30, 50]
a[::-1]	backwards	[60, 50, 40, 30, 20, 10]
a[4:100]	out-of-range stop is fine	[50, 60]

1
Slices never raise errors
An out-of-range slice just gives a shorter (maybe empty) list, but an out-of-range index like a[6] raises IndexError.
2
Length of a slice
For step 1, the length is stop − start (clipped to the list). a[1:4] has 3 items.

Implementation

The list operations you will use daily

Read this as a conversation with one list. Predict every output, especially which methods return something and which only change the list.

python

a = [3, 1, 2]
a.append(5)
a.extend([7, 8])
a.insert(0, 9)
print(a)   # [9, 3, 1, 2, 5, 7, 8]
print(a.pop(), a.pop(0))   # 8 9
print(a)   # [3, 1, 2, 5, 7]
a.remove(2)
print(a)   # [3, 1, 5, 7]
print(a.index(5), a.count(1), 7 in a)   # 2 1 True
a.sort(reverse=True)
print(a)   # [7, 5, 3, 1]
print(sorted(a), a)   # [1, 3, 5, 7] [7, 5, 3, 1]
print(a + [0], a * 2)   # [7, 5, 3, 1, 0] [7, 5, 3, 1, 7, 5, 3, 1]

Reading the code

›append adds one item at the end; extend adds every item of another list; insert(0, x) puts an item at the front and shifts the rest (slow for big lists).
›pop() removes and returns the last item, pop(0) the first. remove(2) deletes the first item equal to 2, not the item at index 2.
›a.sort() changes the list in place and returns None. sorted(a) returns a new sorted list and leaves a alone (the output shows both).
›+ makes a new longer list and * repeats a list. Neither changes a.

Implementation

Copies, and the aliasing trap

b = a does not copy a list: it gives the same list a second name. Slicing (a[:]) makes a shallow copy: a new outer list, but any inner lists are still shared.

python

a = [1, 2, 3]
b = a
c = a[:]
a.append(4)
print(a, b, c)   # [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3]
nested = [[0] * 2 for _ in range(2)]
shallow = nested[:]
shallow[0][0] = 9
print(nested)   # [[9, 0], [0, 0]]

Reading the code

›b = a and a are one list, so appending through a shows up in b. c = a[:] was copied before the append, so it is unaffected.
›In nested, the outer list was copied but the two inner lists were not. Changing shallow[0][0] therefore changes nested too. For fully independent copies use copy.deepcopy.
›The comprehension [[0] * 2 for _ in range(2)] builds a fresh inner list each time. [[0] * 2] * 2 would reuse the same inner list twice, and is the classic way to break a 2D grid.

Implementation

Comprehensions and unpacking

A list comprehension builds a list from a loop in one expression: [expression for item in collection if condition]. Read it as “the expression, for each item, but only if the condition holds”.

python

squares = [x * x for x in range(1, 6)]
print(squares)   # [1, 4, 9, 16, 25]
evens = [x for x in range(10) if x % 2 == 0]
print(evens)   # [0, 2, 4, 6, 8]
pairs = [(i, j) for i in range(2) for j in range(2)]
print(pairs)   # [(0, 0), (0, 1), (1, 0), (1, 1)]
first, *rest = [1, 2, 3, 4]
print(first, rest)   # 1 [2, 3, 4]
grid = [[1, 2, 3], [4, 5, 6]]
print([row[1] for row in grid])   # [2, 5]
print([x for row in grid for x in row])   # [1, 2, 3, 4, 5, 6]

Reading the code

›[x * x for x in range(1, 6)] is the loop-and-append pattern in one line.
›The if at the end filters; two for clauses make a nested loop, with the outer loop first.
›first, *rest = ... assigns the first item to first and the remaining items (as a list) to rest.
›[row[1] for row in grid] takes column 1 of a grid. The double-for version flattens a grid into one list.

Implementation

Tuples in practice

Tuples appear everywhere without you noticing: a function that returns two values returns a tuple, and swapping two variables uses one.

python

point = (3, 4)
x, y = point
print(x, y)   # 3 4
print(point[0], len(point))   # 3 2
single = (7,)
print(type(single).__name__, type((7)).__name__)   # tuple int

def min_max(a):
    return min(a), max(a)

lo, hi = min_max([4, 9, 2])
print(lo, hi)   # 2 9
seen = {(0, 1): "a"}
print(seen[(0, 1)])   # a
a, b = 1, 2
a, b = b, a
print(a, b)   # 2 1
try:
    point[0] = 9
except TypeError:
    print("tuples cannot change")   # tuples cannot change

Reading the code

›x, y = point unpacks the tuple into two names. A function can return several values at once (return min(a), max(a)) and the caller unpacks them.
›(7,) is a tuple, (7) is the number 7. The trailing comma is what makes the tuple.
›A tuple can be a dictionary key (seen[(0, 1)]), which is how grid coordinates are used as keys. A list could not.
›a, b = b, a swaps without a temporary variable: the right side is built first, then assigned.
›Assigning to a tuple item raises TypeError, which the try/except catches and reports.

Worked problem

The runner-up score

The problem

Given a list of scores that may contain duplicates, return the second-highest distinct score. Assume at least two distinct values exist.

The highest score is max(scores).
Remove every copy of the highest score by filtering: keep values not equal to it.
The maximum of what remains is the runner-up. A single max over a comprehension does the filtering and finding together.

python

def runner_up(scores):
    top = max(scores)
    return max(x for x in scores if x != top)

print(runner_up([2, 3, 6, 6, 5]))   # 5
print(runner_up([4, 4, 1]))   # 1

Takeaway. Filtering with a comprehension (x for x in scores if x != top) is more robust than sorting and indexing: with duplicates like [6, 6, 5], the second item in sorted order would still be 6.

Worked problem

Row sums and column sums of a grid

The problem

Given a grid (a list of equal-length rows), return the sum of each row and the sum of each column.

Row sums are easy: sum(row) for each row.
Columns are harder because the grid is stored by rows. zip(*grid) regroups the grid by columns: the first items of every row, then the second items, and so on.
Then sum(col) for each regrouped column.

python

def sums(m):
    rows = [sum(r) for r in m]
    cols = [sum(c) for c in zip(*m)]
    return rows, cols

print(sums([[1, 2, 3], [4, 5, 6]]))   # ([6, 15], [5, 7, 9])

Takeaway. zip(*grid) is the Python idiom for transposing. Knowing it saves a nested loop and a likely off-by-one.

Wrap-up

Remember this

A list holds many values you can change; a tuple holds a fixed group that cannot change and can be a dictionary key.
Indices start at 0, negatives count from the end, and slices exclude the stop and never raise errors.
b = a aliases; copy with a[:] or list(a), and beware shallow copies of nested lists.
Comprehensions and unpacking turn common loops into one expression.
Know which operations are O(n): inserting at the front, in, index, remove.

Cheat sheet

List / tuple: [1, 2] changeable · (1, 2) fixed and hashable · (7,) for one item
Slice: a[start:stop:step]; stop excluded; clips silently
In place vs new: a.sort() → None · sorted(a) → new list
Copy: a[:] or list(a); deepcopy for nested
Comprehension: [expr for x in xs if cond]
Slow ops: insert(0), pop(0), in, index, remove: all O(n)

Top traps to avoid

b = a and expecting an independent copy.
Writing a = a.sort().
Building a grid with [[0] * c] * r.

Mastery check

0 of 15 answered

Answer from understanding, not memory of the page. You need 12 of 15. Each answer is explained, and you can retry as often as you like.

1.For a = [10, 20, 30, 40, 50, 60], what is a[-2:]?
2.After a = [1, 2]; b = a; a.append(3), what is b?
3.What does x = [3, 1, 2].sort() store in x?
4.Which needs a tuple rather than a list?
5.Which operation is O(n) on a list of n items?
6.What does [x for x in range(10) if x % 3 == 0] produce?
7.With a = [1, 2, 3], then b = a and b.append(4), what is len(a)?
8.What is type((1,)).__name__?
9.What does [1, 2, 3][::-1] give?
10.Why can't a list be used as a dictionary key?
11.a = [1, 2]; b = a[:]; b.append(3). What does print(a) show?
12.t = (1, [2]); t[1].append(3). What does print(t) show?
13.What does print([i*i for i in range(4) if i % 2 == 0]) print?
14.a = [3, 1, 2]. What does print(a.sort(), a) print?
15.Which list method removes an element and returns it?

Lists & Tuples

After this lesson you will be able to

Builds on

Unlocks

A shelf of numbered boxes, and a sealed envelope

One variable per value

Lists and tuples side by side

Slicing: which items does each form pick?

Slice rules on a six-item list

The list operations you will use daily

Reading the code

Copies, and the aliasing trap

Reading the code

Comprehensions and unpacking

Reading the code

Tuples in practice

Reading the code

What list operations cost

Edge cases

Mistakes to avoid

How to spot when to use which

The runner-up score

Row sums and column sums of a grid

Wrap-up

Remember this

Cheat sheet

Top traps to avoid

Mastery check

Practice this topic

Warm-up1 problem

Core2 problems

Application1 problem