Sorting and Unique

Unique Values

Collect the distinct values from an 8-element list that contains repeats. A dict accumulates each value as a key (ignoring duplicates), then sorted produces the final ordered list. The trace shows seen filling up — its size staying at 6 even though 8 elements are processed.

By hand

Loop over values writing each v as a key in seen (dict assignment is idempotent for duplicate keys). After the loop, sorted(seen.keys()) gives the unique values in ascending order.

naive.py
Replay: real traced execution (multi-file project)
values = [3, 1, 4, 1, 5, 9, 3, 2]
seen = {}
for v in values:
    seen[v] = True
unique = sorted(seen.keys())
print('RESULT:', unique)

  1. values ← [3, 1, 4, 1, 5, 9, 3, 2]

    1values = [3, 1, 4, 1, 5, 9, 3, 2]2seen = {}
    values this step[3, 1, 4, 1, 5, 9, 3, 2]values

  2. seen ← {}

    1values = [3, 1, 4, 1, 5, 9, 3, 2]2seen = {}3for v in values:
    values this step{}seen

  3. v ← 3

    2seen = {}3for v in values:4    seen[v] = True
    values this step3v

  4. seen ← {3: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{} → {3: True}seen

  5. v ← 1

    2seen = {}3for v in values:4    seen[v] = True
    values this step3 → 1v

  6. seen ← {3: True, 1: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{3: True} → {3: True, 1: True}seen

  7. v ← 4

    2seen = {}3for v in values:4    seen[v] = True
    values this step1 → 4v

  8. seen ← {3: True, 1: True, 4: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{3: True, 1: True} → {3: True, 1: True, 4: True}seen

  9. v ← 1

    2seen = {}3for v in values:4    seen[v] = True
    values this step4 → 1v

  10. seen[v] = True

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())

  11. v ← 5

    2seen = {}3for v in values:4    seen[v] = True
    values this step1 → 5v

  12. seen ← {3: True, 1: True, 4: True, 5: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{3: True, 1: True, 4: True} → {3: True, 1: True, 4: True, 5: True}seen

  13. v ← 9

    2seen = {}3for v in values:4    seen[v] = True
    values this step5 → 9v

  14. seen ← {3: True, 1: True, 4: True, 5: True, 9: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{3: True, 1: True, 4: True, 5: True} → {3: True, 1: True, 4: True, 5: True, 9: True}seen

  15. v ← 3

    2seen = {}3for v in values:4    seen[v] = True
    values this step9 → 3v

  16. seen[v] = True

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())

  17. v ← 2

    2seen = {}3for v in values:4    seen[v] = True
    values this step3 → 2v

  18. seen ← {3: True, 1: True, 4: True, 5: True, 9: True, 2: True}

    3for v in values:4    seen[v] = True5unique = sorted(seen.keys())
    values this step{3: True, 1: True, 4: True, 5: True, 9: True} → {3: True, 1: True, 4: True, 5: True, 9: True, 2: True}seen

  19. for v in values:

    2seen = {}3for v in values:4    seen[v] = True

  20. unique ← [1, 2, 3, 4, 5, 9]

    4    seen[v] = True5unique = sorted(seen.keys())6print('RESULT:', unique)
    values this step[1, 2, 3, 4, 5, 9]unique

  21. stdout ← RESULT: [1, 2, 3, 4, 5, 9]

    5unique = sorted(seen.keys())6print('RESULT:', unique)
    values this stepRESULT: [1, 2, 3, 4, 5, 9]stdout

With NumPy

np.unique(a) returns a sorted array of unique values in one call. The output shape (6,) is smaller than the input shape (8,) — unique reduces the array.

library.py 
import numpy as np

values = [3, 1, 4, 1, 5, 9, 3, 2]
a = np.array(values)
result = np.unique(a)
print('a: shape:', a.shape, 'dtype:', a.dtype, 'values:', a.tolist())
print('result: shape:', result.shape, 'dtype:', result.dtype, 'values:', result.tolist())
print('RESULT:', result.tolist())

a: shape: (8,) dtype: int64 values: [3, 1, 4, 1, 5, 9, 3, 2]
result: shape: (6,) dtype: int64 values: [1, 2, 3, 4, 5, 9]
RESULT: [1, 2, 3, 4, 5, 9]

Implementation notes

  • np.unique always sorts its output — the sorted order is part of the contract, not a side effect. The naive sorted(seen.keys()) call at the print boundary matches this so both RESULT lines agree.
  • np.unique(a, return_counts=True) also returns the count of each unique value, useful for frequency analysis.
  • The Python equivalent of unique is sorted(set(values)). The dict approach here keeps the seen-key pattern visible in the trace (unlike set, which has no meaningful step-by-step membership story for the tracer).
  • Shape, dtype, and values are shown explicitly here because ndarray.__repr__ output varies with NumPy version and print options.