Grouping

Group Count

Count how many times each category appears in a list of labels. The naive loop seeds each new key with 0 the first time it is seen, then increments it on every visit. The trace shows counts growing one key at a time.

By hand

Check whether each label is already a key in counts; if not, seed it with 0. Either way, increment by 1. The if x not in counts events are zero-delta in the trace — the actual change happens on the counts[x] = 0 or counts[x] = counts[x] + 1 lines.

naive.py
Replay: real traced execution (multi-file project)
labels = ['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']
counts = {}
for x in labels:
    if x not in counts:
        counts[x] = 0
    counts[x] = counts[x] + 1
print('RESULT:', {k: counts[k] for k in sorted(counts)})

  1. labels ← ['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']

    1labels = ['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']2counts = {}
    values this step['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']labels

  2. counts ← {}

    1labels = ['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']2counts = {}3for x in labels:
    values this step{}counts

  3. x ← 'a', counts ← {'a': 1}

    pass 1 of 2
    2counts = {}3for x in labels:4    if x not in counts:5        counts[x] = 06    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this step'a'x{'a': 0} → {'a': 1}counts

  4. x ← 'b', counts ← {'a': 1, 'b': 1}

    pass 2 of 2
    2counts = {}3for x in labels:4    if x not in counts:5        counts[x] = 06    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this step'a' → 'b'x{'a': 1, 'b': 0} → {'a': 1, 'b': 1}counts

  5. x ← 'a'

    2counts = {}3for x in labels:4    if x not in counts:
    values this step'b' → 'a'x

  6. if x not in counts:

    3for x in labels:4    if x not in counts:5        counts[x] = 0

  7. counts ← {'a': 2, 'b': 1}

    5        counts[x] = 06    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this step{'a': 1, 'b': 1} → {'a': 2, 'b': 1}counts

  8. x ← 'c'

    2counts = {}3for x in labels:4    if x not in counts:
    values this step'a' → 'c'x

  9. if x not in counts:

    3for x in labels:4    if x not in counts:5        counts[x] = 0

  10. counts ← {'a': 2, 'b': 1, 'c': 0}

    4if x not in counts:5    counts[x] = 06counts[x] = counts[x] + 1
    values this step{'a': 2, 'b': 1} → {'a': 2, 'b': 1, 'c': 0}counts

  11. counts ← {'a': 2, 'b': 1, 'c': 1}, x ← 'b'

    pass 1 of 4
    2counts = {}3for x in labels:4    if x not in counts:5        counts[x] = 06    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this step{'a': 2, 'b': 1, 'c': 0} → {'a': 2, 'b': 1, 'c': 1}counts'c' → 'b'x
    All 4 passes — pass 1 is the card above
    passcountsx
    1{'a': 2, 'b': 1, 'c': 0} → {'a': 2, 'b': 1, 'c': 1}'c' → 'b'
    2{'a': 2, 'b': 1, 'c': 1} → {'a': 2, 'b': 2, 'c': 1}'b' → 'a'
    3{'a': 2, 'b': 2, 'c': 1} → {'a': 3, 'b': 2, 'c': 1}'a' → 'b'
    4{'a': 3, 'b': 2, 'c': 1} → {'a': 3, 'b': 3, 'c': 1}'b' → 'a'

  12. counts ← {'a': 4, 'b': 3, 'c': 1}

    5        counts[x] = 06    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this step{'a': 3, 'b': 3, 'c': 1} → {'a': 4, 'b': 3, 'c': 1}counts

  13. for x in labels:

    2counts = {}3for x in labels:4    if x not in counts:

  14. stdout ← RESULT: {'a': 4, 'b': 3, 'c': 1}

    6    counts[x] = counts[x] + 17print('RESULT:', {k: counts[k] for k in sorted(counts)})
    values this stepRESULT: {'a': 4, 'b': 3, 'c': 1}stdout

The Pythonic way

Counter(labels) does the same counting in one call, returning a Counter subclass of dict. Sorting the keys before printing ensures a deterministic RESULT regardless of insertion order.

library.py 
from collections import Counter
labels = ['a', 'b', 'a', 'c', 'b', 'a', 'b', 'a']
counts = Counter(labels)
print('RESULT:', {k: counts[k] for k in sorted(counts)})

RESULT: {'a': 4, 'b': 3, 'c': 1}

Implementation notes

  • counts grows in insertion order (a first, then b, then c); the printed RESULT uses a comprehension over sorted(counts) to give alphabetical order regardless.
  • Counter also supports counts.most_common() for frequency-sorted output, and arithmetic between counters.
  • The if x not in counts: counts[x] = 0 idiom is equivalent to counts.setdefault(x, 0) or counts.get(x, 0) + 1.