Lists

Make a day06 folder for today’s files, open it in your editor, and run each script from its terminal, as on Days 1 to 5.

Day 5’s temperature program could report the highest of five days, but it could not print all five again afterwards: each value was forgotten as soon as the next one arrived. Today you learn the list, Python’s way of keeping many values together, in order, under one name, so a program can store them, change them, and come back to them.

A teacher has five quiz scores. With what you know so far, that means five variables: score1, score2, score3, score4, score5. Every line that totals them must name all five, and a loop cannot help, because there is no way to say “go through score1 to score5”. What you want is one name for the whole collection, like one sheet of paper with the scores written down it in order.

A list is one value that holds several values in order. Each value inside it is an item (also called an element). You write a list as items separated by commas inside square brackets:

scores = [88, 92, 79]

• [ and ] mark where the list begins and ends.
• The commas separate the items. Here there are three: 88, 92, and 79.
• The order is kept exactly as you wrote it. [88, 92, 79] and [79, 88, 92] hold the same numbers but are different lists.

You met lists briefly on Day 3, as the result of split(), and on Day 4, where an empty list was one of the falsy values. Now you make them yourself. Try these in the REPL:

>>> scores = [88, 92, 79]
>>> scores
[88, 92, 79]
>>> len(scores)
3
>>> empty = []
>>> empty
[]
>>> len(empty)
0
>>> mixed = ["Ana", 15, 1.62, True, None]
>>> mixed
['Ana', 15, 1.62, True, None]
>>> "red green blue".split()
['red', 'green', 'blue']
>>> list("abc")
['a', 'b', 'c']

• len(), which counted the characters of a string on Day 3, counts the items of a list.
• [], with nothing between the brackets, is the empty list: a list with no items yet. Its length is 0. Programs often start with an empty list and fill it as they go (6.4).
• A list can hold values of different types, even True and None. Most real lists hold one kind of thing, such as all scores or all names.
• split() still gives back a list, and list() converts another sequence into a list, just as int() and str() converted values on Day 2. list("abc") makes a list of the string’s characters.

fruits = ["apple", "banana", "cherry"]
print(fruits)
print(type(fruits))
print(f"I have {len(fruits)} fruits.")

['apple', 'banana', 'cherry']
<class 'list'>
I have 3 fruits.

Lists also work with + and *, the same way strings did on Day 3: + joins two lists into a new, longer list, and * repeats a list’s items.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ["ha"] * 3
['ha', 'ha', 'ha']
>>> [0] * 5
[0, 0, 0, 0, 0]

[0] * 5 is a quick way to make a list of five zeros, for example five empty score slots.

>>> snacks = ["chips" "salsa", "nuts"]
>>> snacks
['chipssalsa', 'nuts']
>>> len(snacks)
2

>>> len(["a b", "c", ""])
3

Storing the scores is only half the job; you also need to get one back. Day 3 taught you to read one character of a string with an index in square brackets, counting from 0, and a part of a string with a slice. Lists use exactly the same rules, because a list, like a string, is a sequence: a collection of items kept in order, each at a numbered position. The only difference is what you get back: indexing a string gives a character, and indexing a list gives an item.

>>> scores = [88, 92, 79, 95, 60]
>>> scores[0]
88
>>> scores[4]
60
>>> scores[-1]
60
>>> scores[-2]
95
>>> scores[1:3]
[92, 79]
>>> scores[:2]
[88, 92]
>>> scores[2:]
[79, 95, 60]
>>> scores[::2]
[88, 79, 60]
>>> scores[::-1]
[60, 95, 79, 92, 88]

• scores[0] is the first item. The last item of a 5-item list is at index 4, which is len(scores) - 1, or simply -1.
• A slice scores[start:stop] gives the items from start up to, but not including, stop, just like a string slice and just like range (Day 5). scores[1:3] is index 1 and index 2: two items.
• Leaving out start means “from the beginning”, leaving out stop means “to the end”, and a step works as on Day 3: [::2] takes every second item, and [::-1] gives the items in reverse order.

A slice of a list is a new list, even when it holds only one item (scores[0:1] is [88], a list, while scores[0] is 88, a number). Indexing gives you one item; slicing always gives you a list.

temps = [14, 16, 15, 19, 21, 23, 20]
print("Monday:", temps[0])
print("Sunday:", temps[-1])
print("Midweek:", temps[2:5])
print("Weekend:", temps[5:])
print("Days recorded:", len(temps))

Monday: 14
Sunday: 20
Midweek: [15, 19, 21]
Weekend: [23, 20]
Days recorded: 7

When the items are strings, you can index twice: once to pick the item, then again to pick a character from that string. Python works left to right, so names[2][0] means “item 2, then its character 0”:

>>> names = ["Ana", "Ben", "Chloe"]
>>> names[2]
'Chloe'
>>> names[2][0]
'C'
>>> names[-1][-1]
'e'

names[2] is 'Chloe', and 'Chloe'[0] is 'C'. names[-1][-1] is the last character of the last name. You will use exactly this double indexing for grids in 6.10.

scores = [88, 92, 79]
print("Last score:", scores[len(scores) - 1])
print("Next score:", scores[len(scores)])

Last score: 79
Traceback (most recent call last):
  File ".../day06/index_past_end.py", line 3, in <module>
    print("Next score:", scores[len(scores)])
                         ~~~~~~^^^^^^^^^^^^^
IndexError: list index out of range

>>> colors = ["red", "orange", "yellow", "green", "blue"]
>>> colors[-2]
>>> colors[1:4]
>>> colors[::2]
>>> colors[3][0]

>>> colors = ["red", "orange", "yellow", "green", "blue"]
>>> colors[-2]
'green'
>>> colors[1:4]
['orange', 'yellow', 'green']
>>> colors[::2]
['red', 'yellow', 'blue']
>>> colors[3][0]
'g'

A playlist has a typo in one song title. With a string, Day 3 taught you that you cannot fix one character in place: you have to build a whole new string. Is a list the same?

No, and this is the biggest difference between a list and a string. Put the two side by side:

>>> word = "cat"
>>> word[0] = "b"
Traceback (most recent call last):
  ...
TypeError: 'str' object does not support item assignment
>>> letters = ["c", "a", "t"]
>>> letters[0] = "b"
>>> letters
['b', 'a', 't']

Assigning to one position of a string is a TypeError. Assigning to one position of a list replaces that item. A list is mutable: its contents can be changed after it is made. A string is immutable: it can never change (Day 3). Writing items[index] = value is called item assignment.

Think of a list as a row of numbered boxes. letters[0] = "b" takes out what was in box 0 and puts "b" there instead. It is still the same list object (Day 4); only one box’s contents changed.

Why make lists changeable? Because lists are usually collections that grow and change as a program runs, such as a shopping list or the scores so far, and rebuilding the whole collection for every change would be slow and awkward. Day 3 said immutable strings are safe to share; 6.9 shows the price lists pay for being changeable.

playlist = ["Intro", "Sunrise", "Rainfal", "Night Drive"]
print("Before:", playlist)
playlist[2] = "Rainfall"
playlist[-1] = "Night Drive (Live)"
print("After:", playlist)

Before: ['Intro', 'Sunrise', 'Rainfal', 'Night Drive']
After: ['Intro', 'Sunrise', 'Rainfall', 'Night Drive (Live)']

The right side of an item assignment can use the item’s old value, exactly like count = count - 1 on Day 2: work out the right side first, then store the result in the box. Augmented assignment from Day 5 works on items too:

scores = [70, 85, 90]
scores[0] += 5
scores[2] = scores[2] - 10
print(scores)

[75, 85, 80]

Line 2 means scores[0] = scores[0] + 5: read item 0 (70), add 5, store 75 back in box 0. Line 3 reads item 2 (90), subtracts 10, and stores 80. Item 1 is never mentioned, so it stays 85.

seats = ["Ana", "Ben", "Chloe"]
seats[3] = "Dev"
print(seats)

Traceback (most recent call last):
  File ".../day06/assign_past_end.py", line 2, in <module>
    seats[3] = "Dev"
    ~~~~~^^^
IndexError: list assignment index out of range

shelf = ["jam", "tea", "rice", "oats"]
shelf[1] = "coffee"
shelf[-1] = shelf[0]
shelf[0] = "honey"
print(shelf)
print(len(shelf))

['honey', 'coffee', 'rice', 'jam']
4

Most lists are not typed out in full at the start: a program collects names as people sign up, or scores as a teacher types them. It needs to grow the list.

Day 3 introduced the method: a function that belongs to a value, called with a dot, like name.upper(). String methods always gave back a new string, because strings cannot change. List methods are different: most of them change the list itself. Three of them add items:

>>> guests = ["Ana", "Ben"]
>>> guests.append("Chloe")
>>> guests
['Ana', 'Ben', 'Chloe']
>>> guests.insert(0, "Dev")
>>> guests
['Dev', 'Ana', 'Ben', 'Chloe']
>>> guests.insert(2, "Eli")
>>> guests
['Dev', 'Ana', 'Eli', 'Ben', 'Chloe']
>>> guests.extend(["Fay", "Gus"])
>>> guests
['Dev', 'Ana', 'Eli', 'Ben', 'Chloe', 'Fay', 'Gus']

The REPL shows nothing after each call, because these methods change the list and give back nothing to show. insert(0, "Dev") moves everyone one place right, so Ana is now at index 1. If the index you give insert is past the end, the item simply goes at the end; insert never causes an IndexError.

names = []
while True:
    name = input("Name (blank to finish): ").strip()
    if name == "":
        break
    names.append(name)
print(names)
print(f"{len(names)} names collected.")

Name (blank to finish): Ana
Name (blank to finish): Ben
Name (blank to finish): Chloe
Name (blank to finish):
['Ana', 'Ben', 'Chloe']
3 names collected.

append and extend look similar but treat their argument differently. append always adds one item, even if that item is itself a list. extend goes through its argument and adds each item:

>>> a = [1, 2, 3]
>>> a.append([4, 5])
>>> a
[1, 2, 3, [4, 5]]
>>> len(a)
4
>>> b = [1, 2, 3]
>>> b.extend([4, 5])
>>> b
[1, 2, 3, 4, 5]
>>> len(b)
5
>>> c = [1, 2, 3]
>>> c.extend("hi")
>>> c
[1, 2, 3, 'h', 'i']
>>> d = [1, 2]
>>> d + [3]
[1, 2, 3]
>>> d
[1, 2]

• a.append([4, 5]) adds the whole list [4, 5] as a single item, so a has 4 items and the last one is a list. A list inside a list is called a nested list; 6.10 puts that to good use.
• b.extend([4, 5]) adds 4 and 5 separately, so b has 5 items.
• extend accepts any sequence. A string is a sequence of characters, so c.extend("hi") adds 'h' and 'i'. To add the word as one item, use c.append("hi").
• d + [3] builds a new list and leaves d unchanged, just as + on strings did. append and extend change the list itself. That difference matters a great deal in 6.9.

names = ["Ana", "Ben"]
names = names.append("Chloe")
print(names)

None

nums = [1, 2]
nums.append([3, 4])
nums.extend([5])
print(len(nums))

line = ["Kai", "Lea"]
line.insert(1, "Max")
line.append("Nia")
line.insert(0, "Oto")
line.insert(10, "Pia")
print(line)

['Oto', 'Kai', 'Max', 'Lea', 'Nia', 'Pia']

A queue at a deli counter grows at the back and shrinks at the front. A program that keeps the queue as a list needs to take items out, sometimes by position (“serve whoever is first”) and sometimes by value (“Ben left the queue”).

>>> tasks = ["wash", "dry", "fold", "iron"]
>>> tasks.pop()
'iron'
>>> tasks
['wash', 'dry', 'fold']
>>> tasks.pop(0)
'wash'
>>> tasks
['dry', 'fold']
>>> tasks.remove("fold")
>>> tasks
['dry']
>>> tasks.clear()
>>> tasks
[]
>>> tasks.pop()
Traceback (most recent call last):
  ...
IndexError: pop from empty list

• pop() takes the last item out and gives it back, so the REPL shows 'iron', and you can store it: last = tasks.pop().
• After pop(0), everything shifts one place left, so 'dry' is now at index 0.
• remove("fold") finds the value for you; you do not need to know where it is.
• pop() on an empty list is an IndexError: there is no last item to take.

queue = ["Ana", "Ben", "Chloe"]
queue.append("Dev")
served = queue.pop(0)
print("Now serving:", served)
served = queue.pop(0)
print("Now serving:", served)
print("Still waiting:", queue)

Now serving: Ana
Now serving: Ben
Still waiting: ['Chloe', 'Dev']

remove takes out only the first match, searching from the left:

>>> votes = ["yes", "no", "yes", "yes"]
>>> votes.remove("yes")
>>> votes
['no', 'yes', 'yes']

Only the first "yes" went. To remove every copy, keep removing while there is still one in the list. in asks whether a value is an item of a list, just as it asked whether one string was inside another on Day 3 (6.7 says more):

votes = ["yes", "no", "yes", "maybe", "yes"]
while "yes" in votes:
    votes.remove("yes")
print(votes)

['no', 'maybe']

Each pass removes one "yes". After the third, "yes" in votes is False and the loop ends. The remove call is the line that moves the condition toward False, which is what Day 5 said every while loop needs.

cart = ["bread", "milk"]
cart.remove("eggs")
print(cart)

Traceback (most recent call last):
  File ".../day06/remove_missing.py", line 2, in <module>
    cart.remove("eggs")
    ~~~~~~~~~~~^^^^^^^^
ValueError: list.remove(x): x not in list

cart = ["bread", "milk"]
item = "eggs"
if item in cart:
    cart.remove(item)
else:
    print(f"{item} is not in the cart.")
print(cart)

eggs is not in the cart.
['bread', 'milk']

plates = ["red", "blue", "green", "white"]
top = plates.pop()
plates.remove("red")
plates.append(top)
second = plates.pop(0)
print(top, second)
print(plates)

white blue
['green', 'white']

playlist = ["Intro", "Sunrise", "Rainfall"]
playlist.remove("sunrise")
print(playlist)

ValueError: list.remove(x): x not in list

playlist = ["Intro", "Sunrise", "Rainfall"]
song = "Sunrise"
if song in playlist:
    playlist.remove(song)
else:
    print(f"{song} is not in the playlist.")
print(playlist)

['Intro', 'Rainfall']

Day 5’s for loop went through a string one character at a time. Its real strength is lists: “do this for each guest”, “check each score”. A for loop over a list runs its body once for each item, with the loop variable holding the current item.

guests = ["Ana", "Ben", "Chloe"]
for name in guests:
    print(f"Welcome, {name}!")
print("Everyone is here.")

Welcome, Ana!
Welcome, Ben!
Welcome, Chloe!
Everyone is here.

The loop variable name holds 'Ana', then 'Ben', then 'Chloe'. Adding a guest to the list adds a welcome line without touching the loop.

scores = [72, 45, 88, 59, 91]
passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print("Passing scores:", passing)
print(f"{len(passing)} of {len(scores)} passed.")

Passing scores: [72, 88, 91]
3 of 5 passed.

To number the items as you print them, use enumerate() from Day 5. It works on a list exactly as it did on a string:

chores = ["dishes", "laundry", "trash"]
for number, chore in enumerate(chores, 1):
    print(f"{number}. {chore}")

1. dishes
2. laundry
3. trash

Changing every item. Day 5 warned that assigning to a loop variable does not change the string you are looping over. The same is true for a list:

prices = [4, 10, 7]
for price in prices:
    price = price * 2
print(prices)

[4, 10, 7]

price is just a name for the current item. price = price * 2 makes price refer to a new number; the box in the list still holds the old one. To change the boxes, you need their indexes, so loop over range(len(prices)) (Day 5) and use item assignment (6.3):

prices = [4, 10, 7]
for i in range(len(prices)):
    prices[i] = prices[i] * 2
print(prices)

[8, 20, 14]

range(len(prices)) gives 0, 1, 2, the indexes of the three items, and prices[i] = prices[i] * 2 replaces each box with double its value.

scores = [45, 50, 88, 30]
for score in scores:
    if score < 60:
        scores.remove(score)
print(scores)

[50, 88]

words = ["sun", "moon", "star", "sky"]
long_words = []
for index, word in enumerate(words):
    if len(word) > 3:
        long_words.append(word.upper())
    else:
        words[index] = "-"
print(words)
print(long_words)

['-', 'moon', 'star', '-']
['MOON', 'STAR']

On Day 5 you wrote loops to count, to total, and to find the largest value. Once the values are in a list, Python has a built-in function (a function that is always available, like print and len) for each one.

>>> scores = [72, 45, 88, 59, 91]
>>> len(scores)
5
>>> min(scores)
45
>>> max(scores)
91
>>> sum(scores)
355
>>> sum(scores) / len(scores)
71.0
>>> 88 in scores
True
>>> 100 in scores
False
>>> 100 not in scores
True
>>> max(["pear", "Apple", "fig"])
'pear'
>>> min(["pear", "Apple", "fig"])
'Apple'

• There is no built-in average, but sum(scores) / len(scores) is one.
• not in is the opposite of in: 100 not in scores reads like English and means the same as not (100 in scores).
• min and max compare items with the same rules as < and > from Day 4. For strings that means alphabetical order, with every capital before every small letter, so max of "pear", "Apple", and "fig" is 'pear', and min is 'Apple'.

in on a list is not quite the in you used on strings. On a string, in looks for a piece of text anywhere inside. On a list, it asks whether one of the items is equal to the value, so a part of an item does not count:

>>> "app" in "apple"
True
>>> "app" in ["apple", "pear"]
False
>>> "apple" in ["apple", "pear"]
True

"app" is inside the string "apple", but no item of the list is equal to "app".

scores = [72, 45, 88, 59, 91]
average = sum(scores) / len(scores)
print("Highest:", max(scores))
print("Lowest:", min(scores))
print(f"Average: {average:.1f}")
print("Anyone perfect?", 100 in scores)

Highest: 91
Lowest: 45
Average: 71.0
Anyone perfect? False

The empty list. A program that collects scores might end up with none. The built-ins do not all agree about what to do then:

>>> scores = []
>>> sum(scores)
0
>>> len(scores)
0
>>> max(scores)
Traceback (most recent call last):
  ...
ValueError: max() iterable argument is empty
>>> sum(scores) / len(scores)
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

sum and len of an empty list are 0. But there is no largest item of nothing, so max (and min) stop with a ValueError; “iterable” in the message means “something you can loop over”, here the list. And the average divides by 0, the ZeroDivisionError from Day 2. Guard with the Day 4 rule that an empty list is falsy:

scores = []
if scores:
    print(f"Average: {sum(scores) / len(scores):.1f}")
else:
    print("No scores yet.")

No scores yet.

if scores: is True only when the list has at least one item, so the division runs only when it is safe.

sum = 0
for n in [3, 4, 5]:
    sum += n
print(sum)
scores = [1, 2]
print(sum(scores))

12
Traceback (most recent call last):
  File ".../day06/sum_shadow.py", line 6, in <module>
    print(sum(scores))
          ~~~^^^^^^^^
TypeError: 'int' object is not callable

temps = [3, -2, 8, 0]
print(max(temps) - min(temps), sum(temps) / len(temps))

A leaderboard shows scores from highest to lowest; a class register lists names alphabetically. Putting items in order is called sorting, and Python gives you two ways to do it that look almost alike but behave very differently.

• items.sort() is a list method. It sorts the list in place: it rearranges the items inside that same list and gives back None, like append.
• sorted(items) is a built-in function. It builds a new sorted list and gives it back, leaving the original list exactly as it was.

>>> scores = [72, 45, 88, 59]
>>> ranked = sorted(scores)
>>> ranked
[45, 59, 72, 88]
>>> scores
[72, 45, 88, 59]
>>> scores.sort()
>>> scores
[45, 59, 72, 88]
>>> sorted(scores, reverse=True)
[88, 72, 59, 45]
>>> scores.sort(reverse=True)
>>> scores
[88, 72, 59, 45]

After sorted(scores), scores is still in the order the scores were entered; after scores.sort(), it is not. Both sort from smallest to largest. To sort largest first, add reverse=True inside the parentheses. This is a keyword argument: an argument passed with a name and =, so Python knows which setting you mean. reverse=True means “sort the other way round”.

Reversing is not sorting. The method items.reverse() flips the list’s order in place, last item first, without comparing anything. A slice with step -1 (6.2) gives a reversed copy instead:

>>> stops = ["Park", "Main", "Bridge", "Zoo"]
>>> stops.reverse()
>>> stops
['Zoo', 'Bridge', 'Main', 'Park']
>>> stops[::-1]
['Park', 'Main', 'Bridge', 'Zoo']

reverse() changed stops itself. The slice stops[::-1] gives a new list, reversed back, and leaves stops as it was.

scores = [72, 45, 88, 59, 91, 66]
top_three = sorted(scores, reverse=True)[:3]
print("In order entered:", scores)
print("Top three:", top_three)

In order entered: [72, 45, 88, 59, 91, 66]
Top three: [91, 88, 72]

Sorting uses the same comparisons as min and max, which brings two surprises:

>>> names = ["bea", "Ana", "cal", "Ben"]
>>> sorted(names)
['Ana', 'Ben', 'bea', 'cal']
>>> sorted(["9", "10", "100"])
['10', '100', '9']
>>> sorted([9, 10, 100])
[9, 10, 100]
>>> sorted([3, "10", 7])
Traceback (most recent call last):
  ...
TypeError: '<' not supported between instances of 'str' and 'int'

• Capital letters come before all small letters (Day 4), so 'Ben' sorts before 'bea'.
• Numbers stored as strings sort as text, character by character: "10" comes before "9" because "1" comes before "9". Numbers typed with input() are strings until you convert them with int() or float() (Day 3), so convert before you sort.
• A list that mixes numbers and strings cannot be sorted at all: < does not work between a str and an int, so Python stops with a TypeError.

scores = [72, 45, 88]
ranked = scores.sort()
print(ranked)
print(scores)

None
[45, 72, 88]

prices = [5, 2, 9]
cheap_first = sorted(prices)
prices.reverse()
print(prices, cheap_first)

Here is a puzzle. A program makes a weekend routine by starting from the weekday routine and changing it: no alarm, and pancakes at the end. It only changes weekend. Read it and predict what it prints for weekday:

weekday = ["alarm", "breakfast", "bus"]
weekend = weekday
weekend.remove("alarm")
weekend.append("pancakes")
print("Weekend:", weekend)
print("Weekday:", weekday)
print(weekend is weekday)

Weekend: ['breakfast', 'bus', 'pancakes']
Weekday: ['breakfast', 'bus', 'pancakes']
True

The weekday routine lost its alarm and gained pancakes, even though no line mentions weekday after line 1. This is the day’s most important idea, and it explains why changing one list can change “another” one.

Assignment never copies. Day 4 said that every value is an object in memory and that a variable name refers to an object. weekend = weekday does not make a second list. It makes the name weekend refer to the same list object that weekday refers to. There is one list with two names:

Two names for the same object are aliases, and this situation is aliasing, like a person who answers to both “Robert” and “Bob”. weekend.remove("alarm") changes object #1, so weekday sees the change. Line 7 confirms it with Day 4’s is.

Why did this never bite you with numbers or strings? Because they are immutable (Day 3): nothing can change them in place, so it never matters how many names share one. Lists are mutable, so a change made through one name shows up through every alias.

Copying. To get a second, separate list, ask for a copy. The method items.copy() builds a new list holding the same items:

weekday = ["alarm", "breakfast", "bus"]
weekend = weekday.copy()
weekend.remove("alarm")
weekend.append("pancakes")
print("Weekend:", weekend)
print("Weekday:", weekday)
print(weekend is weekday)

Weekend: ['breakfast', 'bus', 'pancakes']
Weekday: ['alarm', 'breakfast', 'bus']
False

There are three common ways to copy a list, and they all do the same job:

>>> a = [1, 2, 3]
>>> b = a
>>> c = a.copy()
>>> b is a
True
>>> c is a
False
>>> c == a
True
>>> d = a[:]
>>> d is a
False
>>> e = list(a)
>>> e is a
False

• b = a makes an alias: b is a is True.
• a.copy(), the full slice a[:] (every slice is a new list, 6.2), and list(a) each build a new list: is gives False, while == gives True because the contents are equal. This is Day 4’s equality versus identity, now with a reason to care.

Rebinding is not changing. Aliasing only shows when the object itself is changed in place. Assigning a new object to one of the names, called rebinding (Day 2), moves that one name and leaves the other alone:

>>> x = 5
>>> y = x
>>> x = x + 1
>>> y
5
>>> a = [5]
>>> b = a
>>> a = a + [6]
>>> a
[5, 6]
>>> b
[5]

a = a + [6] builds a new list (+ always does, 6.4) and points a at it. b still refers to the original [5]. Compare a.append(6), which would change the shared list, so b would show [5, 6] too.

One more detail: a copy is a new list, but the items in it are the same objects as in the original. For numbers and strings this never matters, because nothing can change them. When the items are themselves lists, it does; 6.10 has the details.

original = [3, 1, 2]
backup = original
sorted_copy = sorted(original)
original.sort()
backup.append(4)
print(original)
print(backup)
print(sorted_copy)

[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3]

A tic-tac-toe board, a seating chart, and a spreadsheet of test scores all have rows and columns. One list is a single row of boxes. A grid needs rows of rows.

6.4 showed that a list can hold another list as an item. A list whose items are all lists of the same length is a grid (also called a 2D list, for two dimensions): the outer list holds the rows, and each row is a list of values. To reach one value, you index twice, as you did with names[2][0] in 6.2: first the row, then the column.

>>> grid = [[1, 2, 3], [4, 5, 6]]
>>> grid[0]
[1, 2, 3]
>>> grid[1][2]
6
>>> len(grid)
2
>>> len(grid[0])
3
>>> grid[1][0] = 40
>>> grid
[[1, 2, 3], [40, 5, 6]]

• grid[0] is the whole first row, [1, 2, 3].
• grid[1][2] is evaluated left to right: grid[1] is the row [4, 5, 6], and its item 2 is 6. Read it as “row 1, column 2”.
• len(grid) is the number of rows, and len(grid[0]), the length of one row, is the number of columns.
• grid[1][0] = 40 picks row 1, then replaces its item 0. Rows are lists, so they are mutable.

Writing a grid with one row per line, as below, makes the rows and columns easy to see. Python allows a list to continue over several lines until its closing bracket, and a comma after the last item is allowed.

board = [
    ["X", "O", "."],
    [".", "X", "."],
    ["O", ".", "."],
]
board[2][2] = "X"
for row in board:
    print(" ".join(row))
print("Center:", board[1][1])

X O .
. X .
O . X
Center: X

When you need the row and column numbers, for example to label rows or to do arithmetic with them, use nested loops (Day 5) over range(len(...)): the outer loop picks each row index, and the inner loop goes through every column index of that row.

scores = [
    [90, 85, 77],
    [60, 72, 81],
]
for row in range(len(scores)):
    total = 0
    for col in range(len(scores[row])):
        total += scores[row][col]
    print(f"Student {row + 1}: total {total}")

Student 1: total 252
Student 2: total 213

total = 0 is inside the outer loop, so it starts again for each student, and print is at the outer loop’s level, so it runs once per row, after the inner loop: the same placement rules as Day 5’s dice_sums.py. Each row is a list of numbers, so sum(scores[row]) would give the same totals in one step; the nested loops show how scores[row][col] reaches every cell.

board = [["."] * 3] * 3
board[0][0] = "X"
for row in board:
    print(" ".join(row))

X . .
X . .
X . .

board = []
for row in range(3):
    board.append(["."] * 3)
board[0][0] = "X"
for row in board:
    print(" ".join(row))

X . .
. . .
. . .

grid = [[1, 2], [3, 4], [5, 6]]
grid[2][0] = grid[0][1] + grid[1][1]
column_total = 0
for row in grid:
    column_total += row[0]
print(grid[-1])
print(column_total)

[6, 6]
10

A shopping list program keeps asking for a command until the user types done. add asks for an item and adds it unless it is already there, remove takes an item off if it is there, and show prints the list in alphabetical order with numbers. This run adds milk, bread, Milk (again, with a capital), and apples, shows the list, tries to remove eggs, removes milk, and finishes:

shopping = []
while True:
    command = input("Command (add, remove, show, done): ").strip().lower()
    if command == "done":
        break
    if command == "add":
        item = input("Item: ").strip().lower()
        if item in shopping:
            print(f"{item} is already on the list.")
        else:
            shopping.append(item)
    elif command == "remove":
        item = input("Item: ").strip().lower()
        if item in shopping:
            shopping.remove(item)
        else:
            print(f"{item} is not on the list.")
    elif command == "show":
        for number, item in enumerate(sorted(shopping), 1):
            print(f"{number}. {item}")
    else:
        print("Unknown command.")
print(f"{len(shopping)} items: {', '.join(sorted(shopping))}")

Command (add, remove, show, done): add
Item: milk
Command (add, remove, show, done): add
Item: bread
Command (add, remove, show, done): add
Item: Milk
milk is already on the list.
Command (add, remove, show, done): add
Item: apples
Command (add, remove, show, done): show
1. apples
2. bread
3. milk
Command (add, remove, show, done): remove
Item: eggs
eggs is not on the list.
Command (add, remove, show, done): remove
Item: milk
Command (add, remove, show, done): done
2 items: apples, bread

• Every item is lowercased (Day 3) before it is checked or stored, so Milk and milk count as the same item, and in (which compares whole items exactly) catches the duplicate.
• show uses sorted, not sort, so the list keeps the order items were added in; only the display is alphabetical.

Day 12 builds a to-do list manager with the same shape: a list that a menu loop adds to, shows, and removes from.

• A list holds several items in order under one name. It indexes and slices exactly like a string: items[0] is the first item, items[-1] the last, and a slice is a new list.
• Lists are mutable: items[i] = value replaces an item, append, insert, and extend add items, and pop, remove, and clear take them out. These methods change the list and give back None (except pop, which gives back the removed item), so never assign their result.
• Loop over a list with for item in items:; build a new list to keep some items, and loop over range(len(items)) to change items in place. len, in, min, max, and sum summarize a list without writing a loop.
• items.sort() sorts the list itself; sorted(items) gives back a new sorted list and leaves the original alone.
• b = a makes an alias, a second name for the same list, so changing one changes “the other”. Use a.copy() for a separate list. A grid is a list of lists, read with grid[row][col].

Do these in your day06 folder. Type each program yourself, run it, and only then open the answer.

numbers = []
for count in range(1, 6):
    number = float(input(f"Number {count}: "))
    numbers.append(number)
average = sum(numbers) / len(numbers)
print("Min:", min(numbers))
print("Max:", max(numbers))
print(f"Average: {average:.2f}")

Number 1: 12
Number 2: 7.5
Number 3: 20
Number 4: 3
Number 5: 9
Min: 3.0
Max: 20.0
Average: 10.30

items = ["apple", "pear", "apple", "fig", "pear", "kiwi"]
unique = []
for item in items:
    if item not in unique:
        unique.append(item)
print(f"Before: {items}")
print(f"After:  {unique}")

Before: ['apple', 'pear', 'apple', 'fig', 'pear', 'kiwi']
After:  ['apple', 'pear', 'fig', 'kiwi']

prices = [4.0, 10.0, 7.5]
sale_prices = prices
for i in range(len(sale_prices)):
    sale_prices[i] = sale_prices[i] * 0.8
print("Regular:", prices)
print("Sale:", sale_prices)

Regular: [3.2, 8.0, 6.0]
Sale: [3.2, 8.0, 6.0]

prices = [4.0, 10.0, 7.5]
sale_prices = prices.copy()
for i in range(len(sale_prices)):
    sale_prices[i] = sale_prices[i] * 0.8
print("Regular:", prices)
print("Sale:", sale_prices)

Regular: [4.0, 10.0, 7.5]
Sale: [3.2, 8.0, 6.0]

line = ["Ana", "Ben", "Cy"]
line.extend(["Dot", "Eve"])
first = line.pop(0)
line.insert(1, first)
print(line[1:3])
print(line[-1], len(line))

['Ana', 'Cy']
Eve 5

scores = [72, 91, 88]
ranked = scores.sort(reverse=True)
print("Top score:", ranked[0])

TypeError: 'NoneType' object is not subscriptable

scores = [72, 91, 88]
ranked = sorted(scores, reverse=True)
print("Top score:", ranked[0])

Top score: 91

a = [1, 2]
b = a
a = a + [3]
b.append(4)
print(a)
print(b)

[1, 2, 3]
[1, 2, 4]

grid = [[1, 2], [3, 4]]
backup = grid.copy()
grid[0][0] = 99
grid.append([5, 6])
print(backup)
print(len(grid), len(backup))

[[99, 2], [3, 4]]
3 2

The official Python Tutorial introduces lists in An Informal Introduction to Python: Lists and lists every list method in Data Structures: More on Lists. Its examples also use tuples and list comprehensions, which you meet on Day 7 and Day 11.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can make a list, including an empty one, and count its items with len(). Reread
• I can read any item or slice of a list, including with negative indexes. Reread
• I can change an item in place and explain why that fails for a string. Reread
• I can add items with append, insert, and extend, and explain how append and extend differ. Reread
• I can remove items with pop, remove, and clear without causing an error. Reread
• I can loop over a list, change its items by index, and build a new list of the items to keep. Reread
• I can summarize a list with len, in, min, max, and sum. Reread
• I can choose between sort() and sorted() and explain the difference. Reread
• I can explain why changing one list can change "another" one, and make a real copy. Reread
• I can read and change any cell of a grid with two indexes. Reread