Collections: Beginner

Reading from a tuple works the way list reading does: index 0 is the first item, -1 is the last, and an item inside a nested tuple takes a second index. The run record holds 4 items of 3 types: 2 strings, an integer and a tuple.

The comma is what tells Python to build a tuple. Parentheses only group, as they do in (2 + 3) * 4. That has 2 consequences: values separated by commas with no parentheses around them are already a tuple, and a single value wrapped in parentheses stays that value. A tuple with 1 item needs a trailing comma.

Python prints a one-item tuple with its trailing comma, (5,), so the printed form shows which kind you are holding.

A list lets you replace, append and remove items. A tuple has no method that changes it, and assigning to one of its indexes stops the program with a TypeError at the line that attempted the edit.

The first print runs, then line 3 raises TypeError: 'tuple' object does not support item assignment, and after: never prints. That final line of the error names the problem. Calling splits.append(280) also stops the program, with AttributeError: 'tuple' object has no attribute 'append', because tuples have no append method.

To correct a value, build a new tuple and assign it to the name, as in point = (38.7223, -9.1400). That line points the name point at a brand-new tuple, and the original was never edited. This is the safety a tuple buys: a record's values change only where code writes out a whole new record on purpose.

The Sets lesson showed that a set refuses a list as a member because a list can change. Dictionary keys follow the same rule, and a tuple of strings and numbers passes it. That makes a tuple the right key when no single value is unique: a runner logs many dates and a date holds many runners, but the pair (runner, date) picks out a single day's distance.

Reading a record by index means remembering that position 2 is the distance and position 3 is the splits. Unpacking gives each position a name instead. Write several names on the left of =, separated by commas, and Python assigns the tuple's items to them in order: first item to first name, second to second.

The reverse mismatch, more names than items, raises ValueError: not enough values to unpack (expected 3, got 2). In both cases no name gets a value, and the program stops on that line.

Put * in front of 1 name and it becomes a collector. Python fills the plain names first, those before the star from the left end and those after it from the right end, then gives every remaining item to the starred name as a list. The 7-item row becomes readable in a single line: run_id, date, *splits = row gives 2 named fields and a list of however many splits the run recorded.

A star relaxes the count, but every plain name still needs an item. a, b, *rest = (1,) stops with ValueError: not enough values to unpack (expected at least 2, got 1). The words at least in the message tell you a starred name was involved.

An assignment can hold 1 starred name at most. With 2, Python would have no way to decide how to divide the leftovers between them, so *a, *b = (1, 2, 3) is refused with a SyntaxError before any line of the program runs.

Often only a few fields matter. By convention the name _ marks a value you are deliberately not using, and *_ discards any number of them. Python treats _ like any other name; the convention tells the next reader that skipping it was on purpose.

A for loop over a list of tuples can unpack each tuple right in its header. Every pass assigns the current tuple's items with the same rules: an exact count without a star, and at least the plain names with one. Here the uploads carry different numbers of splits.

Three built-in functions answer the first questions anyone asks about a column of numbers. sum adds every item, min returns the smallest and max returns the largest. Each takes a whole collection, walks through it and returns 1 value, replacing a loop and a running variable with a single call.

The last 2 lines are the usual combinations: the spread between the slowest and fastest kilometre, and the average split. Division with / always produces a float, which is why the average prints as 298.0. Written out by hand, the work behind sum and min looks like this:

The 2 loops start differently. A total can start at 0 before any item is seen, while a minimum has to start from a real item, since no number is guaranteed to be larger than all of them. That difference decides what an empty collection does, further down.

All 3 accept anything you can loop over: a list, a tuple, a set or a range. min and max also accept 2 or more separate values, which suits picking the larger of 2 readings. sum takes the collection as its first argument, so sum(140, 152) raises a TypeError.

min and max work on anything that < can compare. Strings compare character by character in character-code order, where every uppercase letter sorts before every lowercase one. A dictionary passed to min or max is compared by its keys, so the answer is a key and the values play no part.

max(best_km) returns caro because c is the latest letter among the keys, though Caro ran the shortest distance. When you want the largest number, pass the numbers. The lesson on dictionary views, later in the track, shows the direct way to hand a dictionary's values to max.

An empty collection splits the 3 functions apart. sum starts at 0, finds nothing to add and returns 0. min and max have no item to start from, so they raise an error. A day with no uploads is ordinary input for a daily job, so this case reaches real code.

Without default, max(todays_splits) stops the program with ValueError: max() arg is an empty sequence. The default keyword argument gives min and max a value to return when the collection is empty. Choose one that cannot be mistaken for real data, or check the length first and skip the summary. default works only with a single collection; combined with loose arguments it raises a TypeError.

Mixed types fail as well. sum adds with +, so a string among the numbers raises TypeError: unsupported operand type(s) for +: 'int' and 'str'. min and max compare with <, so min([312, "298"]) raises TypeError: '<' not supported between instances of 'str' and 'int'. A split stored as text must become a number first, which the Type Conversions lesson covers.

In arithmetic Python treats True as 1 and False as 0. Summing a list of comparison results therefore counts how many were true, here the kilometres run in under 5 minutes.

abs returns how far a number lies from zero: the same number with its sign removed. It accepts integers and floats and gives back the type it received.

The everyday form is abs(a - b): how far apart 2 values are, whichever is larger. Subtraction alone returns a signed answer that flips with the order you wrote, and wrapping it in abs makes the order stop mattering. Here a running watch and a map disagree about a route's elevation gain.

Two measurements from different devices rarely agree exactly, so comparing them with == fails over a 1-metre disagreement. A useful check asks whether the gap is small enough: abs(a - b) <= tolerance.

Drop the abs and the second call returns True. The difference 430 - 470 is -40, and -40 is below every positive tolerance, so a watch reading 40 metres low would pass a check it should fail.

Removing the sign removes information. Whether a runner got faster or slower than last week lives in the sign of this_week - last_week, and how big the change was lives in its absolute value. Keep the signed number when direction matters, and take abs when only size does.

A climb profile shows both at once. Five elevation readings give a net change from the first point to the last, and a total amount of climbing and descending along the way. Only the second needs abs.

abs(a) - abs(b) and abs(a - b) are different calculations. With a = -3 and b = 4, the first is 3 - 4, which is -1; the second is abs(-7), which is 7. Only the second is a distance.

abs takes 1 number. A list of gaps needs a loop that calls abs on each item. Passing the list itself, as in abs(gaps), stops the program with TypeError: bad operand type for abs(): 'list', and a number stored as text such as "-12" fails the same way, with 'str' at the end of the message.

len returns how many items a collection holds, as an integer. The same call works on every collection in this track so far, and what counts as 1 item depends on the type.

Two of those results catch people out. The \n escape is 1 character, so the note has length 16 even though it prints on 2 lines. The runs list inside the profile holds 4 numbers, and len(profile) is still 3 because it counts the 3 keys and never looks inside a value.

len counts the items directly inside a collection. A list of 3 tuples has length 3 however long the tuples are. To count everything inside, loop over the outer collection and add up the inner lengths.

A sequence of length n has valid indexes from 0 to n - 1. That is why range(len(splits)) produces exactly the indexes of splits, and why splits[len(splits)] raises IndexError: tuple index out of range. The last item sits at len(splits) - 1, the same position as -1.

A set drops duplicates, so len(set(items)) counts distinct values. Comparing it with len(items) shows whether duplicates exist, a standard check on IDs that are meant to be unique.

A single number is 1 value, so len(1490) raises TypeError: object of type 'int' has no len(). Floats and True fail the same way. Counting the digits of a number is a question about its text form, which needs a conversion first.

An average divides by the length, and an empty list has length 0, so sum(x) / len(x) on it raises ZeroDivisionError: division by zero. A length check in front of the division decides what an empty input returns.

len pairs with starred assignment. The target run_id, runner, *splits needs at least 2 fields, and a row with exactly 2 unpacks to an empty splits list. This job only summarizes runs that carry at least 1 split, so it checks len(row) < 3 first, sets those rows aside and keeps going. The program combines tuples, starred assignment, len and sum.

Ben's row has no splits to summarize, so the length check sets it aside. Without the check it would unpack cleanly to an empty splits list and print r_4822 ben 0 0, a 0-second run that never happened. The other rows unpack with a starred splits list of whatever length they carry, and len and sum summarize it.