Data & Structures

A list is an ordered, changeable collection of items written in square brackets [...]. Here pods holds three service names, and the block shows the everyday things you do with a list: read items, count them, add to it, test membership, and loop over it.

1. pods[0] reads the first item — Python counts from 0, so index 0 is the first, 1 is the second, and so on. pods[-1] counts from the end, so -1 is the last item.
2. pods[:2] is a slice — a smaller list of items 0 and 1 (it stops before index 2). len(pods) tells you how many items there are.
3. pods.append("db") adds a new item onto the end of the list, changing it in place. "web-frontend" in pods checks whether an item is present and gives back True or False.
4. for p in pods: visits each item in turn; the indented print(p) runs once per item, with p holding the current one.

What the output means: The comments show the result of each line: 'checkout-api', 'worker-queue', the two-item slice, the length 3, and so on. The loop would print each pod name on its own line.

Try this: Change pods[0] to pods[3] after the append and see it now returns 'db'. Then try an index that doesn't exist, like pods[9] — Python raises an IndexError, its way of saying "there's no item there".

A dictionary (dict) stores key → value pairs in curly braces {...}. Instead of a position, you look things up by a name (the key). Every chat message and API object in this course is a dict, so this is the pattern you'll reach for most.

1. msg["role"] looks up the value stored under the key "role" and returns 'user'. If the key isn't there, this form crashes with a KeyError.
2. msg.get("missing") is the safe look-up: if the key is absent it returns None instead of crashing. msg.get("ns", "staging") lets you supply a fallback value to use when the key is missing.
3. msg["content"] = "updated" changes the value for an existing key (or adds it if new). msg.keys() lists all the keys.
4. for key, val in msg.items(): loops over both parts of each pair at once, so inside the loop key and val hold the name and its value.

What the output means: You'd see 'user', then None, then 'staging'; the loop prints role = user and content = updated.

Try this: Swap msg["missing"] (square brackets) for the key "missing" and watch it raise KeyError — that's exactly why .get() is safer when a key might not be there.

Real API data is lists inside dicts inside lists. It looks intimidating, but you never read it all at once — you peel one bracket at a time, left to right. This state is a dict with one key, "pods", whose value is a list of pod dicts.

1. state["pods"] steps into the outer dict and hands you the list of pod dicts.
2. state["pods"][0] adds [0] to grab the first pod from that list — itself a dict.
3. state["pods"][0]["name"] steps one more level in, into that pod's "name" key, giving 'checkout-api'.
4. state["pods"][0]["logs"][-1] goes into the first pod's "logs" list and takes the last entry (-1) — 'auth failed'.

What the output means: Each line drills one level deeper; the comments show what you get back at each step, ending with the last log line 'auth failed'.

Try this: Read the value for the second pod's status by hand first, then check it: state["pods"][1]["status"] should give 'Running'. Building the path bracket-by-bracket is the whole skill.

This block introduces two more collections. A tuple is like a list but can't be changed (fixed group, round brackets). A set holds only unique items and answers "is this in here?" very fast (curly braces, but no keys).

1. point = (0.1, 0.9) makes a tuple — handy for a fixed pair like x/y coordinates.
2. chunk, score = ("faq.md#0", 0.87) is unpacking: Python hands the first part to chunk and the second to score in one line. You'll see this a lot when a function returns two things.
3. seen = {"a", "b"} makes a set. seen.add("a") does nothing visible because "a" is already there — sets silently ignore duplicates.
4. "a" in seen is a membership test that's very fast even for huge sets. DESTRUCTIVE = {...} shows the real use: a set of tool names you want to gate.

What the output means: The comments confirm the set stays {'a','b'} after the duplicate add, and "a" in seen is True.

Try this: Try point[0] = 5 — a tuple refuses to change and raises a TypeError. That immutability is the point: use a tuple when the group shouldn't be edited.

A comprehension builds a whole list (or dict) in one line. It reads like English: "[this] for each [item] in [collection] if [condition]". The block first shows the long loop version, then the same thing as a one-liner, so you can see they're identical.

1. The long way starts with an empty list names = [] and appends p["name"] inside a for loop — three lines to collect the names.
2. names = [p["name"] for p in pods] does exactly the same in one line: "take p["name"] for each p in pods".
3. Adding if p["status"] != "Running" filters: only pods that aren't Running contribute, so broken ends up as ['b'].
4. {p["name"]: p for p in pods} is a dict comprehension — it builds a name→pod lookup. any(... for p in pods) checks whether at least one item matches and returns True/False.

What the output means: names becomes ['a', 'b'], broken is ['b'], by_name lets you look up a pod by its name, and the any(...) line is True because pod b is crash-looping.

Try this: Change any to all and re-read: all(...) is only True when every pod matches. This any/all-with-comprehension combo is all over the course's tests.

JSON is just text that mirrors Python's lists and dicts, so it's how fixtures, configs, and API payloads travel and get stored. This block shows the four moves you need: read a JSON file, parse a JSON string, turn Python back into JSON, and read a plain text file.

1. import json loads Python's built-in JSON toolkit.
2. with open("fixtures.json") as f: opens the file and json.load(f) reads it straight into Python dicts/lists. The with block auto-closes the file when done.
3. json.loads('{"replicas": 3}') parses a JSON string (note the s — "load string") into a dict. json.dumps({...}) goes the other way, turning Python into a JSON string.
4. The last with open("crashloop.md") as f: plus f.read() pulls a whole text file into one string — how runbooks get loaded for RAG.

What the output means: state becomes the file's contents as Python objects, data is {'replicas': 3}, line is a JSON string, and text holds the file's text.

Try this: Print type(data) after the json.loads line — you'll see <class 'dict'>, proving the JSON string became a real Python dict you can index.

Regular expressions (regex) find patterns in text. You only need a tiny bit for this course. A pattern like r"\w+" is written as a raw string (the r stops Python from mangling the backslashes) and describes what to look for.

1. re.findall(r"\w+", "reset my password") finds every run of word characters and returns them as a list — here the three words. \w+ means "one or more letters/digits/underscores".
2. re.findall(r"\d+", ...) uses \d+ ("one or more digits") to pull the numbers ['3','7'] out of the text.
3. re.split(r"\n\s*\n", text) splits text wherever there's a blank line (a newline, optional spaces, another newline) — that's how you break a document into paragraphs.
4. re.search(r"\b\d{3}-\d{2}-\d{4}\b", s) looks for the first match of an SSN-shaped pattern (3-2-4 digits); \b is a word boundary so it doesn't match inside a longer number.

What the output means: findall returns lists (['reset','my','password'], ['3','7']); split returns the paragraphs; search returns a match object (or None if nothing matches).

Try this: Change \w+ to \w (drop the +) and re-run — without the + you get every single character separately. The + means "one or more".

Ranking things — search hits, scores, chunks — is everywhere in this course, and sorted() is the tool. The star feature is key=, which lets you sort by any field of each item, not just the item itself.

1. sorted(scores) returns a new list in ascending order (the original is untouched). Adding reverse=True flips it to descending — biggest first.
2. sorted(chunks, key=lambda c: c["score"], reverse=True) sorts a list of dicts by their "score". The lambda is a tiny throwaway function that, given a chunk c, returns the value to sort on. ranked[:3] then takes the top 3.
3. sorted(range(len(scores)), key=lambda i: -scores[i]) sorts the positions 0,1,2 by their score (negated, so highest first) — useful when you need to remember where each value came from.
4. .index(0.9) finds where a value sits, .count(2) tallies how many times it appears, and reversed(...) walks a list backwards.

What the output means: The comments show each result: [0.2, 0.5, 0.9] ascending, the descending flip, the ranked dicts, and the position list [1,2,0].

Try this: Remove reverse=True from the ranked line and see the worst-scoring chunk come first instead. The key=lambda ... + [:k] pair is exactly how the course's retrieval "top-k" works.

Two loop helpers you'll use constantly. enumerate hands you the position number alongside each item (great for numbering citations), and zip walks two lists in step, pairing them up.

1. for i, text in enumerate(chunks, 1): loops over chunks but also gives i, a counter that starts at 1 (the 1 argument) instead of the usual 0 — so the numbering reads naturally for humans.
2. "\n".join(f"[{i}] {c}" for i, c in enumerate(chunks, 1)) is how RAG builds a numbered, citable block of context: number each chunk, then glue them together with newlines.
3. for name, val in zip(names, values): pairs the first name with the first value, the second with the second, and so on — one pass over both lists together.
4. dict(zip(names, values)) turns two parallel lists into a dict, keys from the first and values from the second: {'cpu': 17, 'mem': 96}.

What the output means: The first loop prints [1] first, [2] second, [3] third; the zip loop prints cpu=17 and mem=96; and the final line builds that dict from the two lists.

Try this: Drop the , 1 from the first enumerate and re-run — numbering now starts at [0]. That second argument is just where the counter begins.

Two helpers from the collections module make grouping and counting effortless. Counter tallies how often each value appears; defaultdict is a dict that auto-creates a starting value for any new key, so you skip fiddly "does this key exist yet?" checks.

1. Counter(levels) counts each distinct value in the list in one go, giving Counter({'ERROR': 3, 'INFO': 1, 'WARN': 1}). counts.most_common(2) returns the two most frequent as (value, count) pairs.
2. defaultdict(list) makes a dict where any missing key starts as an empty list [] automatically, so by_service[l["svc"]].append(...) just works even the first time a service is seen.
3. The loop groups each log message under its service, ending up with {'api': ['boom','again'], 'web': ['503']}.
4. defaultdict(float) starts missing keys at 0.0, so scores[cid] += ... can accumulate straight away — no "if cid in scores" guard needed. This is the exact pattern behind the course's RRF scoring.

What the output means: counts tallies the levels (3 errors), by_service groups messages per service, and scores accumulates a running number per id.

Try this: Replace defaultdict(list) with a plain {} and re-run — the first .append now raises KeyError because the key doesn't exist yet. That crash is precisely what defaultdict saves you from.

Real JSON from a model or an API can be broken or missing fields. These techniques stop your agent from crashing on messy data — a running theme in production code.

1. safe_parse wraps json.loads(text) in try / except. If the text isn't valid JSON, Python raises json.JSONDecodeError; the except catches it and returns None instead of letting the whole program die.
2. data.get("status", {}).get("phase", "Unknown") digs two levels down safely: if "status" is missing it falls back to an empty dict {}, so the second .get still works and yields "Unknown" — never a KeyError.
3. json.dumps(data, indent=2, sort_keys=True) pretty-prints with indentation and puts keys in a fixed order — readable for logs and stable for caching.
4. The final with open("out.json", "w") as f: plus json.dump(data, f, indent=2) writes the data out to a file ("w" means "write").

What the output means: safe_parse returns a dict on good input or None on bad; phase is 'Running' here; and the dumps/dump lines print and save neatly formatted JSON.

Try this: Call safe_parse("not json!") and confirm you get None rather than a crash. Then delete the "status" key from data and re-run the phase line — it still returns 'Unknown' instead of erroring.

This ties the whole chapter together into a small tool the DevOps agent would really use: it takes a list of log dicts and answers "which services are erroring, and what are the most common errors?" using a filter, a group-count, sorting, and a Counter.

1. errors = [l for l in logs if l["level"] == "ERROR"] is a filtering comprehension that keeps only the ERROR-level log dicts.
2. by_svc = defaultdict(int) starts each service's count at 0, and the loop adds 1 per error, tallying errors per service.
3. sorted(by_svc.items(), key=lambda kv: -kv[1]) sorts those (service, count) pairs by count, highest first (the - flips ascending into descending) — so the worst offender leads.
4. main() prints a summary line, one line per service ({svc:16} pads the name to 16 characters so columns line up), then Counter(...).most_common(3) lists the three most frequent messages. The if __name__ == "__main__": guard runs main() only when you execute this file directly.

What the output means: The console block shows the result: 3 errors across 2 services, then checkout-api with 2 and web-frontend with 1, then the top error messages each seen once.

Try this: Add another ERROR log for web-frontend and re-run — watch the ranking flip so web-frontend climbs. The sort key does that automatically.

Two words are anagrams if they use the same letters (e.g. "eat" and "tea"). The neat trick: if you sort the letters of each word, anagrams all produce the same sorted string — so that sorted string makes a perfect grouping key.

1. groups = defaultdict(list) makes a dict where each new key auto-starts as an empty list, ready to collect words.
2. "".join(sorted(w)) sorts word w's letters and glues them back into a string — the word's canonical form. "eat" and "tea" both become "aet".
3. groups[...].append(w) files each original word under that canonical key, so all anagrams land in the same bucket.
4. return list(groups.values()) hands back just the buckets — each a list of words that are anagrams of each other.

What the output means: For ["eat","tea","tan","ate"] you'd get groups like [['eat','tea','ate'], ['tan']]. The O(n·k log k) cost comes from sorting each of n words of length k.

Try this: Trace "listen" and "silent" by hand — both sort to "eilnst", so they'd share a bucket. Using a computed value as a dict key is a pattern worth remembering for interviews.

Find the first character in a string that appears exactly once, and return its position. The efficient approach is two passes: count every character first, then walk the string once more looking for the first with a count of 1.

1. freq = Counter(s) makes one pass over the string and records how many times each character appears.
2. for i, c in enumerate(s): walks the string again, giving both the position i and the character c.
3. if freq[c] == 1: checks the pre-computed count; the first character whose count is 1 is unique, so return i hands back its index immediately.
4. return -1 after the loop is the fallback for when no character is unique — a common convention for "not found".

What the output means: For "leetcode" it returns 0 (the first l is unique); for "aabb" it returns -1. It's O(n) — two straight passes, no nested loops.

Try this: Run it on "aabbc" — the answer is 4, the position of c. Counting first, then scanning, avoids re-counting for every character (which would be the slow O(n²) way).