Dictionaries — key-value pairs, access, methods (keys, values, items, get, update)

WHAT is a dictionary?

student = {"name": "Asha", "age": 20, "marks": [88, 91]}

Why keys must be hashable? Python stores keys in a hash table. It runs the key through a hash() function to compute where to store the value. If the key could change (like a list), its hash would change, and Python would "lose" the value. So mutable types are forbidden as keys.

HOW to access values

Action	Syntax	If key missing
Bracket access	`d["name"]`	❌ raises `KeyError`
Safe access	`d.get("name")`	returns `None`
Safe with default	`d.get("name", "?")`	returns `"?"`

Worked example Access in action

d = {"name": "Asha", "age": 20}
print(d["name"])          # Asha
print(d.get("city"))      # None  (no crash!)
print(d.get("city", "NA"))# NA
# print(d["city"])        # KeyError — would crash

Why use .get()? When you expect a key might be absent, .get() lets the program continue instead of crashing. This is the 80% real-world use.

Adding, updating, deleting

Worked example Mutation

d = {"name": "Asha"}
d["age"] = 20            # add new pair
d["age"] = 21            # overwrite existing key
d.update({"city": "Pune", "age": 22})  # add/overwrite many
del d["name"]            # remove a pair
val = d.pop("city")      # remove + return its value

Why this step? d["age"] = 20 and d["age"] = 21 look identical syntactically, but the first creates, the second overwrites — because each key is unique, assignment to an existing key replaces, never duplicates.

The core methods (the 20% you use 80% of the time)

Worked example Iterating — the everyday pattern

scores = {"math": 90, "sci": 85, "eng": 78}
 
for k in scores:              # default loops over KEYS
    print(k)                  # math, sci, eng
 
for k, v in scores.items():   # unpack key AND value
    print(k, "->", v)         # math -> 90, ...
 
total = sum(scores.values())  # 253

Why .items()? It hands you both pieces at once, so you avoid the slow pattern scores[k] inside the loop.

Figure — Dictionaries — key-value pairs, access, methods (keys, values, items, get, update)

Derivation-from-scratch: build a tiny dict yourself

Worked example Reinventing the lookup

Imagine no dictionaries existed. You'd store pairs in two parallel lists:

keys   = ["a", "b", "c"]
values = [ 1 ,  2 ,  3 ]
def lookup(k):
    for i in range(len(keys)):   # O(n) scan
        if keys[i] == k:
            return values[i]

A dict replaces this whole scan with one hash computation. This is WHY the dict syntax d[k] exists: it's the parallel-list pattern made automatic and fast.

Common mistakes

Recall Feynman: explain to a 12-year-old

A dictionary is a magic backpack with labeled pockets. You don't dig through the whole bag — you say a label out loud ("snacks") and the right pocket opens instantly. Each label is special (only one "snacks" pocket), and you can put any toy inside. .get() is the polite way to ask — if there's no "homework" pocket, the bag just says "nothing here" instead of yelling at you.

Flashcards

What type must dictionary keys be?

Unique and hashable (immutable: str, int, tuple)

Why is dict lookup faster than list lookup?

Dict uses a hash table → average O(1); list scans element-by-element → O(n)

Difference between d["x"] and d.get("x")?

d["x"] raises KeyError if missing; d.get("x") returns None (or a given default)

What does d.items() return?

A view of (key, value) tuples

What happens with {"a":1, "a":2}?

The later value wins → {"a": 2} (keys are unique)

What does iterating for x in d give you?

The keys (not the values)

How do you merge dict b into dict a?

a.update(b) (in place; overwrites shared keys)

Why can't a list be a dictionary key?

Lists are mutable/unhashable; their hash could change. Use a tuple instead.

How to remove a key and get its value back?

d.pop("key")

Are keys()/values()/items() copies?

No — they are dynamic views that reflect changes to the dict.

Connections

Lists — ordered mutable sequences
Tuples — immutable sequences (valid dict keys)
Sets — unique hashable elements (same hash-table machinery)
Hashing and Hash Tables
For loops and iteration
Big-O Notation — time complexity

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dictionary ko samjho ek real dictionary ki tarah: tum ek word (key) dhoondhte ho aur uska meaning (value) turant mil jaata hai. List me tumhe position (index) yaad rakhni padti hai, par dictionary me tum naam se (key se) cheez nikaalte ho. Syntax simple hai: {key: value}, jaise student = {"name": "Asha", "age": 20}.

Sabse important baat — dictionary fast hai. List me kuch dhoondhna ho to ek-ek karke saare items check karne padte hain (O(n)), par dictionary hash() function se seedha address nikaal leti hai, to lookup O(1) hota hai chahe lakhon items hon. Yahi dictionary ka asli faayda hai, isiliye banaayi gayi hai.

Access ke do tareeke: d["name"] aur d.get("name"). Yaad rakho — d["name"] agar key nahi hai to program crash (KeyError) ho jaata hai, jabki .get() shaant se None return karta hai. Jab key ke hone ka confirm na ho, hamesha .get() use karo. Methods ka core set: keys() saari keys, values() saari values, items() (key, value) jodi deta hai — loop ke liye perfect: for k, v in d.items().

Do galtiyan jo sab karte hain: (1) list ko key banana — galat, kyunki list mutable/unhashable hai, tuple use karo. (2) Yeh sochna ki duplicate keys dono values rakhengi — nahi, baad waali value purani ko overwrite kar deti hai kyunki keys unique hoti hain. Inhe yaad rakhoge to dictionaries solid ho jaayengi.

Dictionaries — key-value pairs, access, methods (keys, values, items, get, update)

WHAT is a dictionary?

HOW to access values

Adding, updating, deleting

The core methods (the 20% you use 80% of the time)

Derivation-from-scratch: build a tiny dict yourself

Common mistakes

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Introduction to Programming (Python)

Connections