Python Dictionaries — Keys, Values, Hashing

The Story That Explains Dictionaries 🗂️Dictionaries समझाने वाली कहानी 🗂️一个解释字典的故事 🗂️

A dictionary (dict) is Python's built-in mapping type — a collection of key-value pairs where every key is unique. You look things up by key, not by position, and a lookup takes about the same time on average whether the dict has 10 items or 10 million (computer scientists write this as O(1)).

Dictionary (dict) Python का built-in mapping type है — key-value जोड़ियों का संग्रह जिसमें हर key अनोखी है। आप जगह से नहीं, key से ढूँढते हैं, और dict में 10 items हों या 1 करोड़, lookup में औसतन लगभग उतना ही समय लगता है (computer scientists इसे O(1) लिखते हैं)।

字典（dict）是 Python 内置的映射类型 —— 由键值对组成的集合，每个键都是唯一的。你按键而不是按位置查找；无论字典有 10 项还是 1000 万项，查找的平均耗时几乎相同（计算机科学家把它写作 O(1)）。

Keys and Values — The Basic Structure 🔑Keys और Values — बुनियादी ढाँचा 🔑键与值 —— 基本结构 🔑

Every entry is a key-value pair: two objects joined by a colon :. The key is what you ask for; the value is what you get back. Pairs sit inside curly braces {}, separated by commas.

हर entry एक key-value जोड़ी है: colon : से जुड़े दो objects। Key वह है जो आप माँगते हैं; value वह जो आपको मिलती है। जोड़ियाँ curly braces {} के अंदर commas से अलग रहती हैं।

每个条目都是一个键值对：由冒号 : 连接的两个对象。键是你要查的，值是你得到的。键值对放在花括号 {} 里，用逗号分隔。

user = {
    "name": "Asha",
    "age": 30,
    "city": "Pune",
}
print(user["name"], user["age"])

mixed = {
    "name": "Ravi",        # str key
    42: "answer",          # int key
    (1, 2): "point",       # tuple key — allowed!
    None: "nothing",       # None key
}
print(mixed[42], mixed[(1, 2)], mixed[None])

inventory = {
    "apples": 12,                  # int value
    "scores": [88, 92, 75],        # list value
    "config": {"tax": 0.18},       # dict value
    "active": True,                # bool value
}
print(inventory["scores"], inventory["config"]["tax"])   # nested access
print(len(user), list(user))       # 3 pairs; a dict lists its keys in insertion order

Creating Dictionaries — Five Ways ✍️Dictionaries बनाना — पाँच तरीक़े ✍️创建字典 —— 五种方式 ✍️

empty  = {}
prices = {"apple": 1.2, "bread": 3.5, "milk": 2.8}

user = dict(name="Asha", age=30, city="Pune")      # keyword args → str keys
pairs = [("a", 1), ("b", 2), ("c", 3)]
from_pairs = dict(pairs)                          # from (key, value) pairs
zeroed = dict.fromkeys(["x", "y", "z"], 0)        # same value for many keys
squares = {n: n ** 2 for n in range(1, 6)}        # dict comprehension

print(empty, prices)
print(user)
print(from_pairs, zeroed)
print(squares)
print(type({}).__name__, type(set()).__name__)    # {} is a DICT; use set() for an empty set
print(dict(zip(["a", "b"], [1, 2])))              # zip two lists into a dict

What Is Hashing? — The Core Idea #️⃣Hashing क्या है? — मूल विचार #️⃣什么是哈希？—— 核心思想 #️⃣

Python's built-in hash() works on any hashable object — in practice, the built-in immutable types and tuples made of them.

Python का built-in hash() किसी भी hashable object पर चलता है — व्यवहार में, built-in immutable types और उनसे बने tuples।

Python 内置的 hash() 适用于任何可哈希对象 —— 实际上就是内置的不可变类型以及由它们组成的元组。

print(hash(42), hash(-1), hash(True), hash(1.0))  # ints hash to themselves (except -1)
print(hash(3.14))
print(hash((1, 2, 3)))                            # tuples of hashables hash too
print(hash("Asha") == hash("Asha"))               # same key → same hash, always
print(hash("Asha") == hash("Ravi"))               # different keys → almost always different

for bad in ([1, 2, 3], {"a": 1}, {1, 2, 3}):
    try:
        hash(bad)
    except TypeError as err:
        print("TypeError:", err)

# Run this file twice: the str hashes change each time Python starts (hash randomization).
print(hash("Asha"), hash("Ravi"))

How Dictionaries Are Stored in Memory 🧠Dictionaries Memory में कैसे रहती हैं 🧠字典如何存储在内存中 🧠

A dict is a hash table. Since Python 3.6, CPython uses a "compact" design with two parts: a small index table of slots, and an entries list that stores (hash, key, value) in insertion order. To run d["Ravi"] = 25, Python:

Dict एक hash table है। Python 3.6 से CPython दो हिस्सों वाला "compact" design लगाता है: slots की एक छोटी index table, और एक entries list जो (hash, key, value) डालने के क्रम में रखती है। d["Ravi"] = 25 चलाने के लिए Python:

字典是一张哈希表。从 Python 3.6 起，CPython 采用由两部分组成的“紧凑”设计：一张由槽位组成的小索引表，以及一个按插入顺序存放 (哈希, 键, 值) 的条目列表。执行 d["Ravi"] = 25 时，Python 会：

The Hash Table in MemoryMemory में Hash Table内存中的哈希表

What About Collisions?टकराव (Collisions) का क्या?冲突怎么办？

Two different keys can land on the same slot. CPython uses open addressing: it moves to another slot and checks again. It does not simply step to the next slot; it follows a pseudo-random sequence slot = (5 × slot + 1 + perturb) & mask, where perturb brings in more bits of the hash each round. With the toy hash, 'ab' and 'ba' both have hash 195, so they collide at slot 3:

दो अलग keys एक ही slot पर आ सकती हैं। CPython open addressing लगाता है: वह दूसरे slot पर जाकर फिर जाँचता है। वह बस अगले slot पर नहीं जाता; वह एक pseudo-random क्रम मानता है slot = (5 × slot + 1 + perturb) & mask, जहाँ perturb हर बार hash के और bits लाता है। खिलौना hash में 'ab' और 'ba' दोनों का hash 195 है, इसलिए वे slot 3 पर टकराते हैं:

两个不同的键可能落到同一个槽位。CPython 使用开放寻址：换到另一个槽位再检查。它不是简单地走到下一个槽位，而是遵循一个伪随机序列 slot = (5 × slot + 1 + perturb) & mask，其中 perturb 每轮引入哈希的更多位。用玩具哈希时，'ab' 和 'ba' 的哈希都是 195，所以它们在槽位 3 冲突：

import sys
d = {}
last = sys.getsizeof(d)
print(f"empty dict: {last} bytes")
for i in range(25):
    d[i] = i
    size = sys.getsizeof(d)
    if size != last:                 # the hash table just grew
        print(f"after {len(d):>2} items: {size} bytes")
        last = size

Try It — Hash Table Simulatorआज़माएँ — Hash Table Simulator动手试试 —— 哈希表模拟器

Type a key, press Insert, and watch it travel: hash → slot → store. The presets show a collision, a deleted slot (DUMMY) and a resize. The left side is the real CPython layout: an index table of slots plus an entries list in insertion order.

कोई key लिखें, Insert दबाएँ, और उसका सफ़र देखें: hash → slot → store। Presets टकराव, मिटाया गया slot (DUMMY) और resize दिखाते हैं। बाईं ओर असली CPython बनावट है: slots की index table और डालने के क्रम वाली entries list।

输入一个键，点击插入，观察它的旅程：哈希 → 槽位 → 存入。预设展示了冲突、已删除槽位（DUMMY）和扩容。左边是 CPython 的真实布局：由槽位组成的索引表，加上按插入顺序排列的条目列表。

Rules for Valid Dictionary Keys 🔐सही Dictionary Keys के नियम 🔐合法字典键的规则 🔐

A key must be hashable: its hash must never change while it sits in the dict. For built-in types this means immutable — if a key could change, its hash would change, and Python would look in the wrong slot.

Key hashable होनी चाहिए: dict में रहते हुए उसका hash कभी नहीं बदलना चाहिए। Built-in types के लिए इसका मतलब है immutable — अगर key बदल सके तो उसका hash बदलेगा, और Python ग़लत slot में देखेगा।

键必须是可哈希的：它在字典中时哈希值绝不能改变。对内置类型来说，这意味着不可变 —— 如果键能改变，它的哈希也会变，Python 就会去错误的槽位查找。

d = {}
d[42]     = "int key"
d["name"] = "str key"
d[3.14]   = "float key"
d[(1, 2)] = "tuple key"        # great for coordinates
d[None]   = "None as key"
print(d[(1, 2)], len(d))

for bad in ("[1, 2]", '{"a": 1}', "{1, 2}", "(1, [2])"):
    try:
        d[eval(bad)] = "x"
    except TypeError as err:
        print(f"d[{bad}] → TypeError: {err}")

same = {}
same[1] = "int"
same[1.0] = "float"            # 1.0 == 1 and same hash → SAME key
same[True] = "bool"            # True == 1 too!
print(same)                    # the first key (1) stays; the value is replaced

grid = {(0, 0): "start", (1, 2): "tree", (3, 4): "goal"}
print(grid[(1, 2)])

Try It — Key Rules Checkerआज़माएँ — Key Rules Checker动手试试 —— 键规则检查器

Type any Python value and press Try it. The checker runs d[key] = n and tells you whether the key is allowed, and why. Try 1, then 1.0, then True, and watch the dict.

कोई भी Python मान लिखें और Try it दबाएँ। Checker d[key] = n चलाकर बताता है कि key मान्य है या नहीं, और क्यों। 1, फिर 1.0, फिर True आज़माएँ, और dict को देखें।

输入任意 Python 值并点击试一试。检查器会运行 d[key] = n，告诉你这个键是否允许以及原因。依次试试 1、1.0、True，观察字典的变化。

Accessing and Changing Values ✏️मान पढ़ना और बदलना ✏️访问与修改值 ✏️

Reading — Three Waysपढ़ना — तीन तरीक़े读取 —— 三种方式

user = {"name": "Asha", "age": 30, "city": "Pune"}

print(user["name"])
try:
    print(user["email"])
except KeyError as err:
    print("KeyError:", err)

print(user.get("name"), user.get("email"), user.get("email", "n/a"))

if "email" in user:
    print(user["email"])
else:
    print("no email on file")

user["email"] raises KeyError; user.get("email") returns None (or your default); "email" in user checks first. Use [ ] when a missing key would be a real bug, and .get() when missing is normal.

user["email"] KeyError देता है; user.get("email") None (या आपका default) लौटाता है; "email" in user पहले जाँचता है। जब ग़ायब key असली bug हो तब [ ] लगाएँ, और जब ग़ायब होना सामान्य हो तब .get()।

user["email"] 会抛出 KeyError；user.get("email") 返回 None（或你的默认值）；"email" in user 先做检查。当缺少键意味着真正的 bug 时用 [ ]，缺少键属于正常情况时用 .get()。

Writing — Add, Update, Deleteलिखना — जोड़ें, बदलें, मिटाएँ写入 —— 添加、更新、删除

user = {"name": "Asha", "age": 30}
user["city"] = "Pune"          # add a new key (goes to the end)
user["age"] = 31               # update an existing key (keeps its place)
print(user)

del user["city"]               # remove a key (KeyError if missing)
age = user.pop("age")          # remove AND return the value
print(age, user)
email = user.pop("email", None)    # safe: a default instead of KeyError
print(email)

Try It — Key-Value Labआज़माएँ — Key-Value Lab动手试试 —— 键值实验室

Practise the six basic moves on one dict. Pick an operation, type a key (with quotes for text) and press Run. The dict keeps your changes. Try a missing key with [ ] and then with .get() to feel the difference.

एक dict पर छह बुनियादी काम अभ्यास करें। Operation चुनें, key लिखें (text के लिए quotes के साथ) और Run दबाएँ। Dict आपके बदलाव रखती है। फ़र्क़ महसूस करने के लिए ग़ायब key को [ ] से और फिर .get() से आज़माएँ।

在一个字典上练习六种基本操作。选择操作，输入键（文本要加引号），然后点击运行。字典会保留你的修改。用 [ ] 和 .get() 分别试试不存在的键，感受两者的区别。

Dictionary Methods — The Complete Toolkit 🧰Dictionary Methods — पूरा औज़ार-बक्सा 🧰字典方法 —— 完整工具箱 🧰

A dict has 11 public methods. The three view methods — .keys(), .values() and .items() — return live views, not copies: when the dict changes, the view shows the change.

Dict में 11 public methods हैं। तीन view methods — .keys(), .values() और .items() — copies नहीं, live views लौटाते हैं: dict बदलने पर view बदलाव दिखाता है।

字典有 11 个公开方法。三个视图方法 —— .keys()、.values() 和 .items() —— 返回的是实时视图，不是副本：字典变化时，视图也会随之变化。

View MethodsView Methods视图方法

scores = {"Asha": 92, "Ravi": 78, "Meena": 85}
print(scores.keys())
print(list(scores.keys()))
print(scores.values(), sum(scores.values()))
print(scores.items())

keys_view = scores.keys()      # a LIVE view, not a copy
scores["Dev"] = 88
print(keys_view)               # the view shows the new key by itself

Methods That Change the DictDict बदलने वाले Methods修改字典的方法

scores = {"Asha": 92, "Ravi": 78}
scores.update({"Meena": 85, "Dev": 73})   # merge; new keys go to the end
print(scores)
scores.update({"Asha": 99})               # existing key: new value, same place
print(scores)

val = scores.pop("Ravi")
print(val, scores.pop("Missing", -1))
last = scores.popitem()                   # removes the LAST inserted pair
print(last, scores)

groups = {}
for word in ["apple", "ant", "bee", "ball", "cat"]:
    groups.setdefault(word[0], []).append(word)
print(groups)

original = {"a": 1, "b": 2}
duplicate = original.copy()
duplicate["c"] = 3
print(original, duplicate)
merged = original | {"b": 20, "z": 26}    # Python 3.9+: | makes a NEW merged dict
print(merged)
scores.clear()
print(scores)

Try It — Dict Method Simulatorआज़माएँ — Dict Method Simulator动手试试 —— 字典方法模拟器

Run any method on scores and compare before and after. Green pairs were added, orange pairs got a new value, and red pairs were removed. The line kv = scores.keys() ran once at the start — watch it update by itself. That is a live view.

scores पर कोई भी method चलाएँ और पहले व बाद की तुलना करें। हरी जोड़ियाँ जुड़ीं, नारंगी को नया मान मिला, और लाल हटाई गईं। Line kv = scores.keys() शुरू में एक बार चली थी — इसे अपने आप बदलते देखें। यही live view है।

对 scores 运行任意方法，比较之前和之后。绿色是新增的键值对，橙色是值被更新的，红色是被删除的。kv = scores.keys() 只在开始时运行过一次 —— 看它如何自己更新。这就是实时视图。

Complete Methods Referenceपूरी Methods सूची完整方法速查

The for Loop — Walking Through Dictionaries 🔁for Loop — Dictionaries में चलना 🔁for 循环 —— 遍历字典 🔁

A plain for over a dict gives the keys. Use .values() for values only, and .items() for both at once — the most common pattern.

Dict पर सादा for keys देता है। सिर्फ़ मानों के लिए .values() लगाएँ, और दोनों के लिए .items() — यह सबसे आम तरीक़ा है।

直接对字典用 for 得到的是键。只要值就用 .values()，键和值都要就用 .items() —— 这是最常见的写法。

Patterns 1–3 — Keys, Values and ItemsPatterns 1–3 — Keys, Values और Items模式 1–3 —— 键、值与键值对

ages = {"Asha": 30, "Ravi": 25, "Meena": 35}

for name in ages:                  # plain loop → keys
    print(name, end=" ")
print()
for age in ages.values():
    print(age, end=" ")
print()
print(sum(ages.values()), max(ages.values()), sum(ages.values()) / len(ages))

for name, age in ages.items():     # the most common pattern
    print(f"{name} is {age}")

adults = [name for name, age in ages.items() if age >= 30]
print(adults)
for name, age in sorted(ages.items(), key=lambda kv: kv[1]):
    print(f"{name}: {age}")

Pattern 4 — Dict ComprehensionsPattern 4 — Dict Comprehensions模式 4 —— 字典推导式

squares = {n: n ** 2 for n in range(1, 6)}
print(squares)

prices = {"apple": 1.0, "bread": 3.0, "milk": 2.5}
with_tax = {name: price * 1.15 for name, price in prices.items()}
print(with_tax)                    # look at bread: floats are not exact!
print({name: round(price * 1.15, 2) for name, price in prices.items()})

inverted = {v: k for k, v in prices.items()}
print(inverted)
cheap = {name: price for name, price in prices.items() if price < 3}
print(cheap)

Don't Change a Dict While Looping Over ItLoop करते हुए Dict न बदलें不要边遍历边修改字典

ages = {"Asha": 30, "Ravi": 25, "Meena": 35, "Dev": 22}
try:
    for name in ages:
        if ages[name] < 30:
            del ages[name]         # changing the size while looping
except RuntimeError as err:
    print("RuntimeError:", err)

ages = {"Asha": 30, "Ravi": 25, "Meena": 35, "Dev": 22}
for name in list(ages):            # loop over a COPY of the keys
    if ages[name] < 30:
        del ages[name]
print(ages)

ages = {"Asha": 30, "Ravi": 25, "Meena": 35, "Dev": 22}
print({k: v for k, v in ages.items() if v >= 30})   # or build a new dict

Deleting (or adding) keys while looping over the same dict raises RuntimeError: dictionary changed size during iteration. Loop over a copy of the keys with list(ages), or build a new dict with a comprehension.

उसी dict पर loop करते हुए keys मिटाने (या जोड़ने) से RuntimeError: dictionary changed size during iteration आता है। list(ages) से keys की copy पर loop करें, या comprehension से नई dict बनाएँ।

在遍历字典的同时删除（或添加）键，会引发 RuntimeError: dictionary changed size during iteration。请用 list(ages) 遍历键的副本，或用推导式构建新字典。

Try It — Loop Pattern Stepperआज़माएँ — Loop Pattern Stepper动手试试 —— 循环模式单步器

Pick a pattern, edit the dict if you like, and step through it one line at a time. The current pair lights up, the loop variables show their values, and the output grows line by line. The last two tabs show the RuntimeError trap and the safe fix.

कोई pattern चुनें, चाहें तो dict बदलें, और एक-एक line चलाएँ। मौजूदा जोड़ी चमकती है, loop variables अपने मान दिखाते हैं, और output line-दर-line बढ़ता है। आख़िरी दो tabs RuntimeError जाल और सुरक्षित हल दिखाते हैं।

选择一种模式，可以修改字典，然后逐行单步执行。当前的键值对会高亮，循环变量显示它们的值，输出逐行增加。最后两个标签展示 RuntimeError 陷阱和安全的修复方法。

Nested Dictionaries — Structured Data 📂Nested Dictionaries — ढाँचेदार Data 📂嵌套字典 —— 结构化数据 📂

A value can itself be a dict (or a list). This is how you model JSON, database rows and settings files. Each [ ] reads from the result of the one before it, from left to right.

कोई मान ख़ुद एक dict (या list) हो सकता है। JSON, database rows और settings files ऐसे ही बनती हैं। हर [ ] अपने से पहले वाले के नतीजे से पढ़ता है, बाएँ से दाएँ।

值本身也可以是字典（或列表）。JSON、数据库行和配置文件都是这样建模的。每个 [ ] 都从前一个的结果中读取，从左到右。

users = {
    "asha": {
        "name": "Asha Verma",
        "age": 30,
        "skills": ["Python", "SQL"],
        "active": True,
    },
    "ravi": {
        "name": "Ravi Kumar",
        "age": 25,
        "skills": ["Go", "Rust"],
        "active": False,
    },
}
print(users["asha"]["name"])
print(users["asha"]["skills"][0])
print(users.get("meena", {}).get("email", "n/a"))    # safe chained access

for username, info in users.items():
    status = "active" if info["active"] else "inactive"
    print(f"{info['name']:<12} — {status:<8} — {len(info['skills'])} skills")

users["asha"]["skills"].append("Kubernetes")
print(users["asha"]["skills"])

Try It — Nested Dict Explorerआज़माएँ — Nested Dict Explorer动手试试 —— 嵌套字典探索器

Click your way into the users dict from the code above. Each click adds one [ ] to the path. Then test safe access: type a user and a field that may not exist, and compare brackets with the chained .get().

ऊपर के code की users dict में click करते हुए अंदर जाएँ। हर click रास्ते में एक [ ] जोड़ता है। फिर सुरक्षित पहुँच जाँचें: ऐसा user और field लिखें जो शायद मौजूद न हो, और brackets की तुलना .get() की लड़ी से करें।

点击进入上面代码中的 users 字典。每次点击都会在路径上加一个 [ ]。然后测试安全访问：输入一个可能不存在的用户和字段，比较方括号和链式 .get() 的区别。

Complete Practice Program — Word Frequency Counter 📊पूरा अभ्यास Program — शब्द-गिनती 📊完整练习程序 —— 词频统计 📊

This program uses .get(w, 0) + 1 to count, sorted(... key=...) to rank, a dict comprehension to filter, setdefault to group, and .get() for safe lookups. The output below is a real run.

यह program गिनने के लिए .get(w, 0) + 1, क्रम देने के लिए sorted(... key=...), छाँटने के लिए dict comprehension, समूह बनाने के लिए setdefault, और सुरक्षित lookup के लिए .get() लगाता है। नीचे का output असली run है।

这个程序用 .get(w, 0) + 1 计数，用 sorted(... key=...) 排名，用字典推导式过滤，用 setdefault 分组，用 .get() 安全查找。下面的输出是真实运行结果。

# word_counter.py — a real dictionary workout

def count_words(text):
    """Return a dict mapping word → count."""
    counts = {}
    for word in text.lower().split():
        word = word.strip(".,!?;:\"'—")
        if word:
            counts[word] = counts.get(word, 0) + 1
    return counts

def main():
    text = """
    The quick brown fox jumps over the lazy dog.
    The dog barks. The fox runs. The lazy dog sleeps again.
    Python makes counting words a breeze — the dict does the work.
    """

    line = "─" * 40
    counts = count_words(text)

    print(f"{line}\n  WORD FREQUENCY REPORT\n{line}")
    print(f"  Unique words: {len(counts)}")
    print(f"  Total words:  {sum(counts.values())}")

    # Top 5: sort the (word, count) pairs by count, biggest first
    top5 = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)[:5]
    print(f"\n  {'WORD':<10}{'COUNT':>6}  BAR")
    for word, count in top5:
        print(f"  {word:<10}{count:>6}  {'█' * count}")

    # Dict comprehension: words that appear 2+ times
    frequent = {w: c for w, c in counts.items() if c >= 2}
    print(f"\n  Words appearing 2+ times: {frequent}")

    # setdefault: group words by length
    by_length = {}
    for word in counts:
        by_length.setdefault(len(word), []).append(word)
    print("\n  Grouped by length:")
    for length, words in sorted(by_length.items()):
        print(f"    {length} chars: {words}")

    # Safe lookup with .get()
    for query in ["the", "missing"]:
        print(f"  '{query}' appears {counts.get(query, 0)} time(s)")

if __name__ == "__main__":
    main()

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆