Dictionaries, Sets, and Exceptions

Dictionaries: data with names

Three lessons in, you could track an inventory as parallel lists - hostnames in one, IPs in another, models in a third - and pray the indexes stay aligned. Don’t. A dictionary keeps each fact attached to its name:

sw1 = {
    "hostname": "acc-sw01",
    "ip": "10.20.30.11",
    "model": "C9300-48P-4X",
}

Read values by key, write the same way:

>>> sw1["ip"]
'10.20.30.11'
>>> sw1["serial"] = "FOC2217A0AB"     # add a new key
>>> "model" in sw1                     # membership checks the KEYS
True

Ask for a key that isn’t there with square brackets and you get a KeyError - a crash. The professional habit is .get(), which makes a missing key a decision instead:

>>> sw1.get("uptime", "unknown")
'unknown'

That one method is the difference between an inventory report with a few “unknown” cells and a script that dies at device 247 of 300 because one switch never reported uptime.

Real inventories nest

One device is a dict; a fleet is a dict of dicts, keyed by hostname:

inventory = {
    "acc-sw01": {"ip": "10.20.30.11", "model": "C9300-48P-4X"},
    "acc-sw02": {"ip": "10.20.30.12", "model": "C9300-48P-4X"},
}

>>> inventory["acc-sw01"]["ip"]    # read inside-out, left to right
'10.20.30.11'

Loop a dict with .items(), which hands you key and value together:

for hostname, facts in inventory.items():
    print(f"{hostname:<16} {facts['ip']:<14} {facts['model']}")

Get comfortable with this shape now - every network API you will ever call returns nested dictionaries. When you hit REST, NETCONF, and structured show output in the flagship course, the payloads are this, three levels deeper.

Sets: the drift detector

A set is an unordered collection of unique values. Deduplication is the warm-up trick:

>>> seen = [10, 20, 10, 30, 20]
>>> set(seen)
{10, 20, 30}

The real power is the operators. Subtract one set from another and you get what’s in the first but not the second:

>>> intended = {10, 20, 30, 40}      # what the design says
>>> actual = {10, 20, 50}            # what the switch says
>>> intended - actual                # missing from the switch
{30, 40}
>>> actual - intended                # rogue - on the switch, not the design
{50}
>>> intended & actual                # in both
{10, 20}

That’s config drift detection - the entire concept - in three lines.

Drift detection is two subtractions

Rendering diagram…

View diagram source - it's just text (Mermaid). Diagrams-as-code is how modern network docs work; the flagship course has a free module on it.

flowchart TD
  I["intended<br/>{10, 20, 30, 40}"] --> M["intended - actual"]
  A["actual<br/>{10, 20, 50}"] --> M
  I --> R["actual - intended"]
  A --> R
  M --> MO["missing from switch:<br/>{30, 40}"]
  R --> RO["rogue on switch:<br/>{50}"]

Exceptions: one bad input shouldn’t kill the run

You’ve already met exceptions - KeyError, ValueError, the AttributeError from Lesson 1’s .strip typo. So far they’ve meant a dead script. try/except turns them into handled cases:

raw = "twenty"                  # parsed from somewhere ugly

try:
    vlan = int(raw)
except ValueError:
    print(f"skipping unparseable VLAN: {raw!r}")
    vlan = None

The block under try is the risky part; the block under except runs only if that specific exception fires. At fleet scale this is survival: when device 113’s output is malformed, you want one logged skip - not three hours of work lost at 2 AM.

Catch the specific exception you expect. The lazy form:

try:
    vlan = int(raw)
except:                # ← catches EVERYTHING, including your own typos
    vlan = None

For dict lookups you now have two idioms - .get() when a default is fine, try/except KeyError when a missing key needs real handling (logging, counting, alerting). Both beat the crash.

Inventories, drift detection, and graceful failure

Try it yourself (Python runs in your browser)

inventory = {
  "acc-sw01": {"ip": "10.20.30.11", "vlans": [10, 20, 30]},
  "acc-sw02": {"ip": "10.20.30.12", "vlans": [10, 20, 50]},
}

# Drift between the two switches, one operator each way
a = set(inventory["acc-sw01"]["vlans"])
b = set(inventory["acc-sw02"]["vlans"])
print("on sw01, not sw02:", a - b)
print("on sw02, not sw01:", b - a)

# Your turn:
# 1. Print sw02's IP with one nested lookup
# 2. inventory.get("acc-sw03", {}) - what does it return? Why no crash?
# 3. Wrap int("voice") in try/except ValueError and print "skipped"

Output appears here. First run downloads the Python runtime (~10 MB), so give it a few seconds.

Prove it (graded lab)

Write each function in the editor, then Run grader - it runs the lesson’s real checks right here in your browser, nothing to install. Green means the skill is yours, and these are the building blocks the Lesson 10 capstone (netaudit) is assembled from.

Five functions:

device_facts(hostname, ip, model) - build the standard device dict
safe_get_ip(inventory, hostname) - nested lookup that returns None instead of crashing
unique_vlans(vlan_lists) - collapse many VLAN lists into one sorted, deduped list
missing_vlans(intended, actual) - the drift report: sorted list of what’s missing
parse_vlan_id(text) - int() with a safety net: None for garbage input

Graded lab - 5 checks, run right here

"""Lesson 4 exercises — dictionaries, sets, and exceptions on network data.

Implement each function so that `pytest -q` passes. No imports needed.
"""


def device_facts(hostname, ip, model):
    """Return a dict with exactly three keys — "hostname", "ip", "model" —
    mapped to the given values.

    Example:
        >>> device_facts("acc-sw01", "10.20.30.11", "C9300-48P-4X")
        {'hostname': 'acc-sw01', 'ip': '10.20.30.11', 'model': 'C9300-48P-4X'}
    """
    raise NotImplementedError


def safe_get_ip(inventory, hostname):
    """Return the "ip" value for `hostname` in a nested inventory dict,
    or None if the device (or its ip) isn't there. Must not raise.

    Example:
        >>> inv = {"sw1": {"ip": "10.0.0.1"}}
        >>> safe_get_ip(inv, "sw1")
        '10.0.0.1'
        >>> safe_get_ip(inv, "sw9") is None
        True

    Hint: .get() chains nicely — a missing device can default to {}.
    """
    raise NotImplementedError


def unique_vlans(vlan_lists):
    """Given a list of VLAN lists (one per switch), return a single SORTED
    list of the unique VLAN IDs across all of them.

    Example:
        >>> unique_vlans([[10, 20], [20, 30], [10, 50]])
        [10, 20, 30, 50]

    Hint: build a set as you loop, convert to sorted list at the end.
    """
    raise NotImplementedError


def missing_vlans(intended, actual):
    """Return a SORTED list of VLANs that appear in `intended` but not in
    `actual` — the drift report. Both arguments are lists.

    Example:
        >>> missing_vlans([10, 20, 30, 40], [10, 20, 50])
        [30, 40]

    Hint: set difference, then sorted().
    """
    raise NotImplementedError


def parse_vlan_id(text):
    """Convert `text` to an int VLAN ID, tolerating surrounding whitespace.
    Return None if the text isn't a number — never raise.

    Example:
        >>> parse_vlan_id(" 20 ")
        20
        >>> parse_vlan_id("voice") is None
        True

    Hint: try/except ValueError around int(text.strip()).
    """
    raise NotImplementedError

Edit the functions above, then Run grader. First run downloads the Python runtime (~10 MB), so give it a few seconds.

Reveal a reference solution

"""Lesson 4 reference solutions. Read after an honest attempt."""


def device_facts(hostname, ip, model):
    return {"hostname": hostname, "ip": ip, "model": model}


def safe_get_ip(inventory, hostname):
    return inventory.get(hostname, {}).get("ip")


def unique_vlans(vlan_lists):
    found = set()
    for vlans in vlan_lists:
        for vlan in vlans:
            found.add(vlan)
    return sorted(found)


def missing_vlans(intended, actual):
    return sorted(set(intended) - set(actual))


def parse_vlan_id(text):
    try:
        return int(text.strip())
    except ValueError:
        return None

Read it, close it, then re-type your own version from memory. Wrong turns are where the learning is.

Check your understanding

Your report script crashes with KeyError: "serial" halfway through the fleet. Which change makes it finish, marking unknowns?

Summary

Dictionaries attach names to facts - sw1["ip"], .get() for the keys that might not be there, .items() for looping, and nesting for fleets, which is the exact shape every API response takes. Sets answer membership questions at a glance: dedupe with set(), and read config drift straight off the subtraction operator (intended - actual). Exceptions make failure a handled case - catch the specific error you expect (ValueError, KeyError) and let everything else crash loudly, because a bare except: converts your own bugs into silent wrong answers. Next lesson: regular expressions - pulling structured facts out of show output that .split() can’t reach.