defaultdict Silent Key Creation — Memory Leak Pattern

from collections import defaultdict

# Group words by their first letter
words = ['apple', 'avocado', 'banana', 'blueberry', 'cherry', 'apricot']

# Without defaultdict — verbose
groups = {}
for word in words:
    if word[0] not in groups:   # check before every append
        groups[word[0]] = []
    groups[word[0]].append(word)

# With defaultdict — clean
groups = defaultdict(list)     # list() called for every new key
for word in words:
    groups[word[0]].append(word)  # KeyError impossible

print(dict(groups))
# {'a': ['apple', 'avocado', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

# Count occurrences
counts = defaultdict(int)     # int() returns 0
for word in words:
    counts[word[0]] += 1
print(dict(counts))  # {'a': 3, 'b': 2, 'c': 1}

from collections import defaultdict

# Any callable works as a factory
dd_set   = defaultdict(set)        # empty set for missing keys
dd_zero  = defaultdict(lambda: 0)  # 0 for missing keys
dd_const = defaultdict(lambda: 'N/A')  # string constant

# Nested defaultdict — for 2-level grouping
transactions = [
    ('2026-03-01', 'Engineering', 500),
    ('2026-03-01', 'Marketing',   300),
    ('2026-03-02', 'Engineering', 700),
]

# Date → Department → total
monthly = defaultdict(lambda: defaultdict(int))
for date, dept, amount in transactions:
    monthly[date][dept] += amount

print(dict(monthly['2026-03-01']))
# {'Engineering': 500, 'Marketing': 300}

from collections import defaultdict

# Gotcha 1: Accidental creation in iteration
dd = defaultdict(list)
items = ['a', 'b', 'c']
for item in items:
    if dd[item]:  # This creates an empty list for 'a', 'b', 'c' even if not present
        pass
print(len(dd))  # 3 — all created

# Fix: use .get()
dd = defaultdict(list)
for item in items:
    if dd.get(item):  # does not create entry
        pass
print(len(dd))  # 0

# Gotcha 2: Masking KeyError that should propagate
def process_key(dd, key):
    # If key missing, we want to crash, not create a default
    value = dd[key]  # creates default silently
    return value.upper()  # possible AttributeError if default is [], not str

from collections import OrderedDict

# Since Python 3.7, regular dicts maintain insertion order
# So when is OrderedDict useful?

# 1. Order-sensitive equality
od1 = OrderedDict([('a', 1), ('b', 2)])
od2 = OrderedDict([('b', 2), ('a', 1)])
regular1 = {'a': 1, 'b': 2}
regular2 = {'b': 2, 'a': 1}

print(od1 == od2)       # False — order matters for OrderedDict
print(regular1 == regular2)  # True — regular dict ignores order

# 2. move_to_end() — useful for LRU patterns
cache = OrderedDict()
cache['page1'] = 'content1'
cache['page2'] = 'content2'
cache['page3'] = 'content3'

cache.move_to_end('page1')  # move to most recently used
print(list(cache.keys()))   # ['page2', 'page3', 'page1']

cache.move_to_end('page2', last=False)  # move to front (LRU = least recently used)
print(list(cache.keys()))   # ['page2', 'page3', 'page1']

from collections import defaultdict, OrderedDict

# URL router using defaultdict(list)
routes = defaultdict(list)
routes['GET'].append('/users')
routes['POST'].append('/users')
routes['GET'].append('/users/<id>')
print(dict(routes))
# {'GET': ['/users', '/users/<id>'], 'POST': ['/users']}

# LRU cache using OrderedDict
class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)  # evict least recently used