Python Dictionaries — Language Specification¶

object.__getitem__(self, key) -> value
# Called by d[key]. Raises KeyError if key absent.

object.__setitem__(self, key, value)
# Called by d[key] = value.

object.__delitem__(self, key)
# Called by del d[key]. Raises KeyError if absent.

object.__iter__(self) -> iterator
# Iterates over keys.

object.__len__(self)  -> int
# Number of key-value pairs.

object.__contains__(self, key) -> bool
# Called by 'key in d'. Default falls back to __iter__.

# Inheriting from Mapping requires only: __getitem__, __iter__, __len__
# Provides default implementations of: get, __contains__, keys, items, values, __eq__, __ne__

# Inheriting from MutableMapping additionally requires: __setitem__, __delitem__
# Provides: pop, popitem, clear, update, setdefault

object.__or__(self, other)   -> dict   # d1 | d2 (Python 3.9+)
object.__ior__(self, other)  -> self   # d1 |= d2
object.__ror__(self, other)  -> dict   # other | d1 (reflected)

object.__missing__(self, key) -> value
# Called by dict.__getitem__ if key is not found.
# Used by collections.defaultdict.

# d.get(key, default): read-only; does not modify dict
val = d.get("x", 0)

# d.setdefault(key, default): inserts if missing; modifies dict
val = d.setdefault("x", 0)

# d[key]: raises KeyError if missing
val = d["x"]

d = {}
d[1] = "one"
d[True] = "true"     # overwrites d[1]!
d[1.0] = "float one" # overwrites d[True]!

print(d)       # {1: 'float one'}
print(len(d))  # 1
print(d[True]) # 'float one'
print(d[1.0])  # 'float one'

# Last value wins for duplicate keys in comprehension:
d = {k % 3: k for k in range(9)}
print(d)   # {0: 6, 1: 7, 2: 8}  — last assignment wins

d = {"a": 1, "b": 2, "c": 3}
try:
    for k in d:
        del d[k]   # RuntimeError!
except RuntimeError as e:
    print(e)   # dictionary changed size during iteration

# Safe: iterate over a copy
for k in list(d.keys()):
    del d[k]
print(d)   # {}

data = [("Alice", 90), ("Bob", 85), ("Alice", 95), ("Bob", 88)]
groups = {}
for name, score in data:
    groups.setdefault(name, []).append(score)
print(groups)
# {'Alice': [90, 95], 'Bob': [85, 88]}

# Equivalent with defaultdict:
from collections import defaultdict
groups2 = defaultdict(list)
for name, score in data:
    groups2[name].append(score)
print(dict(groups2))

d = {"a": 1, "b": 2, "c": 3}
print(d.popitem())   # ('c', 3)  — last inserted
print(d.popitem())   # ('b', 2)
print(d.popitem())   # ('a', 1)

d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"b": 20, "c": 30, "d": 40}

common_keys = d1.keys() & d2.keys()
print(common_keys)   # {'b', 'c'}

only_d1 = d1.keys() - d2.keys()
print(only_d1)   # {'a'}

# items() supports set ops only if values are hashable:
common_items = d1.items() & d2.items()
print(common_items)   # set() — no item is identical in both

defaults = {"color": "blue", "size": "medium", "weight": 1.0}
overrides = {"color": "red", "material": "steel"}

config = defaults | overrides
print(config)
# {'color': 'red', 'size': 'medium', 'weight': 1.0, 'material': 'steel'}

# In-place:
defaults |= overrides
print(defaults)
# Same result; defaults modified in-place

from collections import defaultdict, Counter, ChainMap, OrderedDict
from typing import TypedDict

# ----------------------------------------------------------------
# 1. Creating dicts
# ----------------------------------------------------------------
d1 = {"name": "Alice", "age": 30}
d2 = dict(name="Bob", age=25)
d3 = dict([("x", 1), ("y", 2)])
d4 = {k: k**2 for k in range(5)}

print(d1)   # {'name': 'Alice', 'age': 30}
print(d4)   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}


# ----------------------------------------------------------------
# 2. Access patterns
# ----------------------------------------------------------------
d = {"a": 1, "b": 2}
print(d["a"])              # 1
print(d.get("c"))          # None
print(d.get("c", 0))       # 0
print(d.setdefault("c", 0)) # inserts "c": 0, returns 0
print(d)                   # {'a': 1, 'b': 2, 'c': 0}


# ----------------------------------------------------------------
# 3. Mutation
# ----------------------------------------------------------------
d = {"a": 1}
d["b"] = 2        # add
d["a"] = 10       # update
del d["b"]        # delete
print(d)           # {'a': 10}

d.update({"b": 20, "c": 30})
print(d)           # {'a': 10, 'b': 20, 'c': 30}

val = d.pop("b")
print(val, d)      # 20 {'a': 10, 'c': 30}

last = d.popitem() # LIFO: ('c', 30)
print(last, d)     # ('c', 30) {'a': 10}


# ----------------------------------------------------------------
# 4. dict views
# ----------------------------------------------------------------
d = {"x": 1, "y": 2, "z": 3}
keys   = d.keys()
values = d.values()
items  = d.items()

d["w"] = 4   # views update dynamically
print(list(keys))    # ['x', 'y', 'z', 'w']
print(list(values))  # [1, 2, 3, 4]

for k, v in items:
    print(f"{k}={v}", end=" ")   # x=1 y=2 z=3 w=4
print()


# ----------------------------------------------------------------
# 5. Key membership
# ----------------------------------------------------------------
d = {"a": 1, "b": 2}
print("a" in d)         # True   (O(1))
print("c" not in d)     # True
print("a" in d.keys())  # True   (equivalent)
print(1 in d.values())  # True   (O(n))


# ----------------------------------------------------------------
# 6. ** unpacking (PEP 448)
# ----------------------------------------------------------------
defaults = {"debug": False, "timeout": 30}
overrides = {"timeout": 60, "verbose": True}
config = {**defaults, **overrides}
print(config)   # {'debug': False, 'timeout': 60, 'verbose': True}


# ----------------------------------------------------------------
# 7. | merge operator (Python 3.9+, PEP 584)
# ----------------------------------------------------------------
base = {"a": 1, "b": 2}
patch = {"b": 20, "c": 30}
merged = base | patch
print(merged)   # {'a': 1, 'b': 20, 'c': 30}

base |= patch   # in-place
print(base)     # {'a': 1, 'b': 20, 'c': 30}


# ----------------------------------------------------------------
# 8. defaultdict
# ----------------------------------------------------------------
word_count = defaultdict(int)
for word in "the quick brown fox jumps over the lazy dog".split():
    word_count[word] += 1
print(dict(word_count))

grouped = defaultdict(list)
data = [("math", 90), ("eng", 85), ("math", 92), ("eng", 88)]
for subject, score in data:
    grouped[subject].append(score)
print(dict(grouped))   # {'math': [90, 92], 'eng': [85, 88]}


# ----------------------------------------------------------------
# 9. Counter
# ----------------------------------------------------------------
from collections import Counter
text = "mississippi"
c = Counter(text)
print(c)                        # Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
print(c.most_common(2))         # [('s', 4), ('i', 4)]
print(c["s"])                   # 4
print(c["z"])                   # 0 (no KeyError for Counter!)


# ----------------------------------------------------------------
# 10. True/1/1.0 same key
# ----------------------------------------------------------------
d = {1: "one"}
d[True] = "True"    # overwrites d[1]
d[1.0]  = "1.0"    # overwrites again
print(d)            # {1: '1.0'}
print(len(d))       # 1


# ----------------------------------------------------------------
# 11. TypedDict (Python 3.8+)
# ----------------------------------------------------------------
class Movie(TypedDict):
    title: str
    year: int
    rating: float

# TypedDict is for static type checking only; runtime is just a dict:
m: Movie = {"title": "Inception", "year": 2010, "rating": 8.8}
print(m["title"])           # Inception
print(isinstance(m, dict))  # True


# ----------------------------------------------------------------
# 12. ChainMap (lookup through multiple dicts)
# ----------------------------------------------------------------
defaults = {"color": "blue", "user": "guest"}
environ  = {"user": "alice"}
config   = ChainMap(environ, defaults)
print(config["user"])    # alice  (environ wins)
print(config["color"])   # blue   (from defaults)
print(list(config.keys()))  # ['user', 'color']