Pairs, dictionaries, and files

Round brackets with a comma between the values make a tuple, Python's name for a small, fixed group of values. Here the pair holds a true label and a predicted label for one example. You can read one item by position, just like a list: pair[0] is the first. The line true_label, predicted = pair is called unpacking. Python takes the two values out of the pair and gives each its own name, in order: the first value goes to the first name, the second to the second. The number of names on the left must match the number of values.

Predict all four printed lines, then run.

A function can hand back more than one value: write them after return with commas between them. Python packs them into a tuple, and the line that calls the function unpacks them straight into names. You will meet this pattern in the next module. The tool that splits data into a training part and a testing part returns four values at once, and the program catches them with four names on the left of a single = sign.

Run it, then call the function with a list of your own numbers.

In the lists lesson you compared predictions with true labels using positions: for i in range(len(truth)). zip does the same job more directly. It walks through both lists at once and hands you one pair per turn: the first item of each list, then the second of each, and so on. The for line unpacks each pair into two names. Zip pairs items purely by position, so the two lists must describe the same examples in the same order. It cannot check that for you.

Before running, find the one position where the two lists disagree.

Sometimes you need an item and also where it sits, for example to report which image in a batch was misread. enumerate gives you both as a pair on every turn: the position, counting from 0 as always in Python, and the value. The for line unpacks the pair into position and label.

Run and check that the first position is 0, not 1.

A dictionary stores pairs of a key and a value, the way a printed dictionary pairs a word with its meaning. Curly brackets hold the pairs, and a colon joins each key to its value. Here each key is a symbol you might type in a drawing, and each value is the brightness that symbol stands for. brightness["#"] looks up the value stored under the key "#". A list finds things by position; a dictionary finds them by key. in asks whether a key exists. Asking for a key that is not there stops the program with a KeyError.

Predict each printed value, then run.

A dictionary is a natural place to keep a count for each label. The loop visits every label. counts.get(label, 0) means "the count so far for this label, or 0 if we have not seen it yet". Adding 1 and storing the result under the same key updates that one count. At the end, counts.items() hands back every key with its value as a pair, which the second loop unpacks. In the functions lesson you counted one label at a time; this counts every label in one pass through the list.

Count the 3s, 8s, and 2s yourself before running.

Programs often make a new list by doing the same thing to every item of an old list. The first part uses the loop you already know: start with an empty list and append each result. The line after it does exactly the same work in one line. This is called a list comprehension. Read it left to right as "value divided by 16, for each value in raw". The last line combines a comprehension with the dictionary: "the brightness of each symbol, for each symbol in the row". A string can be looped over one character at a time, so each symbol is one character. Later you will see one comprehension inside another, which turns a whole drawing into numbers one row at a time. It is this same idea used twice.

Check that the loop version and the one-line version print the same list.

any(...) answers the question "is this true for at least one item?". all(...) answers "is this true for every item?". Inside the brackets is a condition written in the same style as a comprehension: "the length of the row is not 4, for each row in rows". Programs use these checks to test data before it reaches a model, for example that every row of a drawing has the right width.

Predict the three answers before running.

Putting the letter f straight before the opening quote makes an f-string. Inside it, anything in curly brackets is worked out and its value is written into the text. That includes a calculation such as correct / total. F-strings are handy when a line must have an exact shape, such as p001,7 in a predictions file, where the spaces that print adds between values would get in the way.

Run and compare each printed line with the code that made it.

A running program forgets everything when it ends, so anything worth keeping goes into a file. open("settings.json", "w") opens a file for writing (the w), creating it if it does not exist. The with line gives the open file a name, handle, for the indented lines below it, and closes the file properly when they finish. JSON is a common text format for dictionaries and lists. json.dump writes the dictionary into the file as text; indent=2 just makes that text easier to read. The second with block opens the same file for reading (no w), and json.load turns the text back into a dictionary. After the run, the editor offers the file for download.

Run, then find settings.json in the output area and download it if you like.

max finds the largest item. With a list of dictionaries, Python has to be told what "largest" should mean, and key= supplies that rule. lambda result: result["accuracy"] is a tiny function written in one line: given one record, it returns that record's accuracy. max applies the rule to every record and returns the whole record whose rule gave the biggest number. You will use exactly this later to choose between model settings you have measured.

Predict which record wins before running.