Modern Python

A loop that has to read something before it can test it traditionally writes the read twice — once before the loop, once at the bottom. Two copies of one line, which can drift apart.

while chunk := stream.read(3):
    print(chunk)

:= gives the value a name while the condition uses it. An empty string is falsy, so the loop ends when the reads run out.

Your task: rewrite the loop below with a walrus, so the read appears once. The output must not change:

abc
def
g

A comprehension that filters on a computed value normally computes it twice — once for the condition, once to keep. On anything expensive that doubles the work.

[parsed for row in rows if (parsed := parse(row))]

The brackets round the walrus are required here, and they help anyway.

Your task: the filter below calls parse twice per row. Rewrite it with a walrus so each row is parsed once. The calls list records every call, so the count proves it:

[12, 7]
4

Four rows, four calls — not eight.

match is not a switch statement. A case matches a shape and binds names out of it in the same step.

match command.split():
    case ["deploy", environment]:
        return f"deploying to {environment}"
    case _:
        return "unknown"

A bare name inside a pattern is a capture, not a comparison — it takes whatever was in that position. The pattern above matches a two-item list whose first item is exactly "deploy".

Your task: write route(command) handling four shapes:

deploying to staging
all good
scaling eu to 3
unknown command: rm -rf /

deploy <env>, status on its own, scale <env> <count>, and anything else echoing the original command.

A case can carry an if, called a guard: the shape has to match and the guard has to hold. If the guard fails, matching carries on with the next case.

That ordering matters. A specific case with a guard belongs above the general one it falls through to — the same first-match rule as an elif chain from module 2-01.

Your task: write scale(command) accepting scale <env> <count> only when the count is all digits, and refusing it otherwise:

scaling eu to 3
count must be a number: lots
unknown

Mapping patterns are what make match genuinely useful on JSON. A pattern names the keys it cares about and ignores the rest, so a payload with six fields still matches a pattern naming two.

case {"type": "order", "quantity": int(quantity)} if quantity > 0:

int(quantity) is a class pattern: it matches only when the value really is an int, and captures it. So a quantity that arrived as text falls through to the next case rather than being used.

Your task: write handle(payload) with four cases:

order for 3
bad order: -1
bad order: 3
ignored: ping

A valid order, a negative quantity, a quantity that is text, and a payload of some other type.

zip stops at the shorter of its inputs. When the two are supposed to be the same length, that turns a data problem into a smaller report that looks perfectly fine.

zip(names, scores, strict=True)   # raises when they disagree

Your task: run it and notice the report is missing two rows with no complaint. Then add strict=True and handle the ValueError:

kenji 88
ada 71
mismatched columns: zip() argument 2 is shorter than argument 1

Print the pairs first, then the complaint — so the failure is visible rather than silent.

lstrip takes a set of characters and keeps eating from the left while it recognises them. Everybody reads it as "remove this prefix", and it is not:

"staging_server.log".lstrip("staging_")       # "erver.log"
"staging_server.log".removeprefix("staging_") # "server.log"

The s of "server" was in the set, so it went too. The bug is silent, plausible, and hard to spot in a list of filenames.

removeprefix and removesuffix do what people meant, and leave the string alone when the affix is not there.

Your task: fix the cleaning so each name loses exactly the prefix and the extension:

['server', 'stats', 'access']
staging_other.txt

The second line is a name that has neither affix, which must come back untouched.

| merges two dictionaries into a new one, with the right-hand side winning. It is the copy-and-update from module 2-05, without either step being possible to forget.

settings = DEFAULTS | user_config    # a new dict; DEFAULTS untouched
settings |= extra                    # in place, on settings

The two-line version had a real hazard: calling update without copying first quietly edits the defaults for the rest of the program. The operator cannot do that.

Your task: merge the three layers with |, then apply one more with |=, and prove DEFAULTS survived:

{'port': 9000, 'debug': True, 'timeout': 30, 'region': 'eu'}
{'port': 9000, 'debug': True, 'timeout': 5, 'region': 'eu'}
{'port': 8080, 'debug': False, 'timeout': 30}

@functools.cache remembers what a function returned for a given set of arguments, and hands the same answer back without running the body again.

It works only on a pure function — same input, same output, nothing else touched — for the reason that should now be familiar: caching something that depends on the clock, a file or a global gives you a stale answer forever.

Your task: cache the lookup, so repeated calls do the work once. The calls list records every real execution:

1250
1250
990
['tea', 'whisk']
2

Four calls, two of them repeats, so only two reach the body.