Tuples & Sets

Round brackets, or often none at all — it is the commas that make a tuple. Everything that reads a list works on one.

row = ("T-1003", "high", 90)
row[0]     # "T-1003"
row[-1]    # 90
len(row)   # 3

A list says "any number of these". A tuple says "exactly these, in this order" — which is what a row of a file actually is.

Your task: build row with those three values, then print the id, the minutes, the length, and whether "high" is in it:

T-1003
90
3
True

row[1] = "low" raises TypeError: 'tuple' object does not support item assignment. There is no method that would do it either — the whole point of the type is that there is not.

What you do instead is build a new one. Slicing and + both work on tuples exactly as they do on strings, and for the same reason:

row = row[:1] + ("low",) + row[2:]

Note the comma in ("low",). Without it those brackets are just grouping, and you would be trying to add a plain string to a tuple.

Your task: run it, read the error, then rebuild row with the priority changed to low:

('T-1003', 'low', 90)

Several names on the left of an assignment take a sequence apart in one line:

ticket_id, priority, minutes = line.split(",")

This is worth doing at the moment data arrives. parts[1] scattered through the code below is a chance to use the wrong index every time it appears; priority is not.

The count must match exactly. Too many or too few values raises a ValueError, which is a useful failure — it means the line was not the shape you assumed.

Your task: unpack the line into three names, convert the minutes, and print:

T-1003
high
91

The last line is the minutes plus one, to prove it is a number.

When you want the front of a sequence by name and everything else in one go, a star collects the remainder into a list:

command, *arguments = "deploy staging --dry-run".split()
# command   -> "deploy"
# arguments -> ["staging", "--dry-run"]

The starred name always ends up a list, even when it catches one item or none. It can go at either end — *body, last = lines is equally valid — but only one star is allowed, because two would be ambiguous.

Your task: split the command line, take the command by name and the rest into arguments, then print the command, the arguments, and how many there are:

deploy
['staging', '--dry-run']
2

A set holds each value at most once. Building one from a list is how you remove duplicates:

distinct = set(items)
len(set(items))   # how many distinct

A set has no order and no positions, so distinct[0] raises. When output has to be stable, sorted() hands you back a list in a predictable order.

Your task: from the raw tags, print how many there are in total, how many are distinct, how many duplicates that means, and the distinct ones sorted:

7
5
2
['dicts', 'errors', 'lists', 'loops', 'sets']

x in some_list walks the list until it finds a match. x in some_set goes straight there, the same way a dictionary finds a key.

On ten items the difference is invisible. Checking each of a hundred thousand things against a list of a hundred thousand things is the difference between a second and an afternoon — and it is the same code either way, so the container is the whole decision.

Your task: build a set of the known tags, then report on three candidates. Print the set's size, then True or False for each candidate, then the ones that were not known, sorted:

4
True
False
False
['files', 'threads']

Comparing two collections is a loop with a condition, four slightly different ways. Sets make each of them one line:

a | b   # union — in either
a & b   # intersection — in both
a - b   # difference — in a but not b
a ^ b   # in one but not both

Watch the direction. a - b is not b - a, and a report that has them the wrong way round is confidently backwards.

Your task: work out what was added, what was removed, and what stayed, then print each sorted, and finally the size of the union:

['dicts', 'sets']
['functions', 'strings']
['errors', 'lists', 'loops']
7

Dictionary keys have to be unchangeable, which rules out lists and lets in tuples. That is what makes a compound key possible:

sales[("eu", "09")] = 1750

Region and month together identify one figure, and neither alone does. The alternative — a dictionary of dictionaries, or a string key like "eu-09" that has to be split apart again — is more code and more chances to disagree with itself.

Your task: total the sales by region and month. Then print the totals for two specific cells and the number of cells:

1750
900
3

This code deduplicates the queue and reports the next three jobs. It deduplicates correctly and reports the wrong three, because set() threw the order away and nothing downstream can get it back.

A set is the right tool for "have I seen this". It is the wrong tool for "what came first". When you need both — distinct, in original order — keep the list and use a set only for the check:

seen = set()
for job in queue:
    if job not in seen:
        seen.add(job)
        unique.append(job)

Your task: rewrite it so the duplicates are gone and the queue order survives:

['build', 'test', 'deploy', 'notify']
4