An ordered list is more than a bag of numbers

Start with four boxes

Imagine drawing four boxes in a row, placing one number in each box. You've just created two distinct pieces of information: the numbers themselves (the values), and the left-to-right locations that hold them (the positions).

You might notice the number 7 appears twice, but they're not exactly the same thing. One 7 occupies position 0, while the other sits at position 3. The position tells us where it is, and the value tells us what it is.

Order is information

Take a look at these lists:

They contain the exact same three values, yet they're different lists because the values at positions 0 and 2 don't match up. This is the exact same distinction we make in code between an array and a set. A set just tracks whether a value is present, while an array preserves its exact location.

What makes two lists equal?

Two ordered lists are considered equal only when two things are true: their lengths match, and the values at every corresponding position match. This translates directly into a practical way to check equality in code. First, we compare lengths. If they're different, we can stop immediately. Otherwise, we just walk through from position 0 to the end, comparing each pair.

def same_list(left, right):
    if len(left) != len(right):
        return False
    for i in range(len(left)):
        if left[i] != right[i]:
            return False
    return True

Length and position

The length of a list is just the number of entries it holds. A four-entry list has four valid positions. Since software (and this book) generally starts counting at zero, those positions are 0, 1, 2, and 3.

Lists can hold symbols too

A list doesn't have to contain concrete numbers. [a, b, c] is a list of symbols. Using symbols is a powerful trick because it lets us reason about every possible value all at once. We can talk about "swapping the first and last entries" without needing to know what a and c will eventually be.

A position gets its meaning from a contract

The list itself stores values and their order, but it doesn't know what position 2 actually means. That meaning comes from an agreement we make outside the list itself: maybe it's hour 2 in a temperature series, the blue channel in an RGB color, or a specific feature in a vector embedding. We can only meaningfully compare two lists coordinate-by-coordinate if they share this same external agreement.

values = [7, 4, 7]
for position, value in enumerate(values):
    print(position, value)

assert values[0] == values[2]
assert 0 != 2  # equal payloads, different addresses