Day 09: Lists, dictionaries, frequency counts, and safe Git recovery

Instructions

Study source: within this activity's existing reading/practice time, use Automate the Boring Stuff with Python, 3rd edition, Chapter 6; Practice Questions; Appendix B answers, then explain one connection to the local task in your own words. Keep the local exercise and acceptance checks; use its original explanation if the external source is unavailable. Spaced-review warm-up: from memory, state the counting invariant from Day 08 and explain why a = [1]; b = a; a.append(2) changes b. You will see the same aliasing with lists today.

New ideas: list(text) gives a list of code points. A list keeps items in order and append adds to its end. A dictionary maps keys to values; d[key] = value adds or replaces, key in d checks for a key, and d.get(key, 0) returns 0 instead of failing when the key is missing. Dictionaries remember insertion order.

Predict every printed line, then run:

chars = list("ñu猫")
print(chars, len(chars))
print(len("n\u0303u"), "n\u0303u" == "ñu")
seen = []
for ch in "abca":
    if ch not in seen:
        seen.append(ch)
print(seen)
ages = {}
ages["猫"] = 3
ages["犬"] = 5
ages["猫"] = ages["猫"] + 1
print(ages, len(ages), "猫" in ages, ages.get("鳥", 0))
alias = seen
alias.append("z")
print(seen)
print(list(""), {})

Instructions

Study source: within this activity's existing reading/practice time, use Automate the Boring Stuff with Python, 3rd edition, Chapter 7; Practice Questions; Appendix B answers, then explain one connection to the local task in your own words. Keep the local exercise and acceptance checks; use its original explanation if the external source is unavailable. Spaced review: this generalizes Day 08's single counter to one counter per distinct character.

Invariant: at the start of each iteration, counts maps every code point visited so far to the number of times it has been visited, and the values add up to the number of code points visited. most_common keeps the character with the highest count seen so far; a tie keeps the earlier character because only a strictly larger count replaces it.

Predict every line and write a trace table (ch / counts) for "banana" before running:

def char_frequencies(text):
    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1
    return counts
def most_common(counts):
    best_char = None
    best_count = 0
    for ch in counts:
        if counts[ch] > best_count:
            best_char = ch
            best_count = counts[ch]
    return best_char
print(char_frequencies(""))
print(char_frequencies("banana"))
print(char_frequencies("猫猫犬"))
print(char_frequencies("aA"))
print(char_frequencies("😀😀"))
print(char_frequencies("e\u0301") == {"e": 1, "\u0301": 1})
print(most_common(char_frequencies("banana")))
print(most_common(char_frequencies("abab")))
print(most_common(char_frequencies("")))

Instructions

Spaced review: Part A repeats the git restore pattern from Days 07–08 with today's frequency file.

New idea: git revert creates a new commit that undoes an earlier commit, so history is kept rather than rewritten. It works only on committed changes and refuses to run while the working tree has uncommitted changes to the affected file. That is why you must not commit a baseline, make an uncommitted edit, and then try git revert.

Use a new temporary directory for each part and predict every output first.

Part A, uncommitted edit, restored with Git:

cd "$(mktemp -d)"
git init -q
git config user.name "Learner"
git config user.email "[email protected]"
cat > freq.py <<'EOF'
def char_frequencies(text):
    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1
    return counts
print(char_frequencies("猫猫犬"))
EOF
git add freq.py
git commit -q -m "Add char_frequencies"
python3 freq.py
printf 'print(char_frequencies(""))\n' >> freq.py
git status --short
python3 freq.py
git restore freq.py
git status --short
python3 freq.py

Part A alternative, a saved copy (no Git command needed to recover):

cd "$(mktemp -d)"
git init -q
git config user.name "Learner"
git config user.email "[email protected]"
cat > freq.py <<'EOF'
def char_frequencies(text):
    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1
    return counts
print(char_frequencies("猫猫犬"))
EOF
git add freq.py
git commit -q -m "Add char_frequencies"
python3 freq.py
cp freq.py freq.py.saved
printf 'oops\n' >> freq.py
cp freq.py.saved freq.py
rm freq.py.saved
git status --short
python3 freq.py

Part B, committed change, reverted with a new commit:

cd "$(mktemp -d)"
git init -q
git config user.name "Learner"
git config user.email "[email protected]"
cat > freq.py <<'EOF'
def char_frequencies(text):
    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1
    return counts
print(char_frequencies("猫猫犬"))
EOF
git add freq.py
git commit -q -m "Add char_frequencies"
python3 freq.py
printf 'print("debug")\n' >> freq.py
git commit -q -am "Add debug print"
python3 freq.py
git revert --no-edit HEAD > /dev/null
git log --format=%s
git diff HEAD~2 HEAD
git status --short
python3 freq.py

Part C, why the order matters: this shows git revert refusing while an uncommitted edit is present.

cd "$(mktemp -d)"
git init -q
git config user.name "Learner"
git config user.email "[email protected]"
cat > freq.py <<'EOF'
def char_frequencies(text):
    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1
    return counts
print(char_frequencies("猫猫犬"))
EOF
git add freq.py
git commit -q -m "Add char_frequencies"
python3 freq.py
printf 'print("debug")\n' >> freq.py
git commit -q -am "Add debug print"
printf 'oops\n' >> freq.py
git revert --no-edit HEAD 2> /dev/null || echo "revert refused: uncommitted change present"
git status --short

Instructions

Spaced review: this combines Day 08 loop invariants and functions with today's dictionaries. Do not open the reference answer or use AI until your evidence is submitted.

Specification for text_stats(text), which returns a dictionary with exactly these keys:
- "code_points": the number of Unicode code points in text (len(text)).
- "distinct": the number of different code points.
- "frequencies": a dictionary from each code point to its count, in first-seen order.
- "most_common": the code point with the highest count; on a tie, the one seen first; None for empty text.
Count Unicode code points exactly: no case folding and no normalization, so "e\u0301" is two code points. Each call must start from fresh state.

Before writing code, predict the full result for "", "abca", "😀😀a", and "naïve naïve", and the code_points, distinct, and most_common values for "e\u0301". Then implement, test, and finally write the loop invariant of your frequency loop and of your most-common loop.