Python Dictionary Comprehension — एक line में dict बनाना

Syntax — list comprehension जैसा, बस colon जुड़ा

Dictionary comprehension वही grammar follow करता है जो list comprehension करता है। सिर्फ दो फर्क हैं: square bracket की जगह curly bracket, और expression की जगह key: value pair।

{ key: value  for item in iterable  if condition }
  ^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^
  हर entry      कहाँ से आ रहा है      optional filter
  का आकार

names = ["asha", "ravi", "meera"]

# वो loop जिसकी जगह ये लेता है
lengths = {}
for n in names:
    lengths[n] = len(n)

# comprehension
lengths = {n: len(n) for n in names}
# {'asha': 4, 'ravi': 4, 'meera': 5}

# users की list से id -> name का lookup table
users = [{"id": 7, "name": "Asha"}, {"id": 9, "name": "Ravi"}]
by_id = {u["id"]: u["name"] for u in users}
# {7: 'Asha', 9: 'Ravi'}

सबसे काम का use case आखिरी वाला है — किसी list को lookup table में बदलना। ये O(n) में बनता है और उसके बाद हर खोज O(1) में होती है, जबकि list में बार-बार खोजना O(n) हर बार लगता है।

Filter करना

आखिर वाला if तय करता है कौन सी entries बनेंगी। ध्यान रहे — list comprehension की तरह यहाँ भी filter सबसे आखिर में जाता है, expression के अंदर नहीं:

scores = {"asha": 91, "ravi": 42, "meera": 77, "imran": 35}

passed = {name: s for name, s in scores.items() if s >= 40}
# {'asha': 91, 'ravi': 42, 'meera': 77}

# key पर filter
long_names = {n: s for n, s in scores.items() if len(n) > 4}

# value बदलना और filter दोनों साथ
curved = {n: s + 5 for n, s in scores.items() if s >= 40}

# खाली values हटाना
config = {"host": "x", "port": "", "user": "admin"}
clean = {k: v for k, v in config.items() if v}
# {'host': 'x', 'user': 'admin'}

Key और value उलटना

.items() पर loop चलाकर key और value की जगह बदल सकते हो। पर एक गंभीर चेतावनी है — उलटने पर duplicate keys बन सकते हैं:

mapping = {"a": 1, "b": 2, "c": 1}

reversed_map = {v: k for k, v in mapping.items()}
# {'a': 1, 'b': 2, 'c': 1}  ->  {1: 'c', 2: 'b'}
#                                          ^^^ 'a' गायब हो गया!

# दो keys की value 1 थी, तो बाद वाली ने पहले वाली को overwrite कर दिया।
# dict में key unique होनी चाहिए — यही नियम यहाँ चुपचाप data मिटा देता है।

mapping = {"a": 1, "b": 2, "c": 1}
reversed_map = {v: k for k, v in mapping.items()}
print(len(mapping), len(reversed_map))   # 3 2  — एक entry खो गई, कोई error नहीं

# अगर उलटना ही है और values unique नहीं हैं, तो list of pairs बनाओ
pairs = [(v, k) for k, v in mapping.items()]      # कोई data नहीं खोता

कोई warning नहीं मिलती। बस एक entry चुपचाप गायब हो जाती है। इसलिए उलटने से पहले हमेशा पूछो: क्या सारी values unique हैं? Unique हैं तो set(mapping.values()) की length dict की length के बराबर होगी।

Nested dict के साथ

students = {
    "class_a": {"asha": 91, "ravi": 42},
    "class_b": {"meera": 77, "imran": 35},
}

# हर class के top scorer
top = {cls: max(marks, key=marks.get) for cls, marks in students.items()}
# {'class_a': 'asha', 'class_b': 'meera'}

# हर class का average
avg = {cls: sum(m.values()) / len(m) for cls, m in students.items()}

# nested comprehension — structure बनाए रखना
scaled = {c: {n: s * 1.1 for n, s in m.items()}
          for c, m in students.items()}

# दो level flatten करना
flat = {n: s for m in students.values() for n, s in m.items()}
# {'asha': 91, 'ravi': 42, 'meera': 77, 'imran': 35}

आखिरी line ध्यान देने लायक है: for m in students.values() बाहरी loop है और for n, s in m.items() अंदरूनी। बाहरी हमेशा पहले आता है।

कब for loop ही लिखना चाहिए

List comprehension की ही सीमाएँ यहाँ भी लागू होती हैं — comprehension में सिर्फ expressions आ सकते हैं:

• हर item पर validation और error handling चाहिए — try/except statement है, तो loop लिखो।
• एक से ज़्यादा dict भरने हैं — comprehension एक ही collection देता है।
• बीच में कुछ log करना है — comprehension में side effect लिखना पढ़ने में भयानक होता है।
• Condition जटिल है — तीन-चार शर्तें हों तो named boolean variable के साथ loop साफ रहता है।

# validation चाहिए — loop लिखो
parsed = {}
for row in rows:
    try:
        parsed[row["id"]] = int(row["qty"])
    except (KeyError, ValueError) as e:
        print(f"skipping {row}: {e}")

# दो dict एक साथ भरने हैं — loop
by_id, by_name = {}, {}
for u in users:
    by_id[u["id"]] = u
    by_name[u["name"]] = u

आम गलतियाँ

• Colon भूल जाना। {n len(n) for n in names} — पहले key: value लिखो, फिर for।
• Square bracket लगा देना। {n: len(n) for n in names} dict है; [...] लगाओगे तो SyntaxError मिलेगा।
• Duplicate keys पर भरोसा करना। कोई error नहीं आता, data चुपचाप मिट जाता है — ऊपर वाला swap example देखो।
• .items() भूल जाना। {k: v for k, v in scores} पर ValueError मिलेगा, क्योंकि dict पर सीधा loop सिर्फ keys देता है।
• बड़े dict पर ज़रूरत से ज़्यादा use। अगर नतीजा एक बार ही पढ़ना है तो generator वाला सोच बदलता नहीं — dict comprehension हमेशा पूरा dict बनाता है।

scores = {"asha": 91}
{k: v for k, v in scores}          # ValueError: not enough values to unpack
{k: v for k, v in scores.items()}  # सही

Set comprehension भी यही grammar है

Curly bracket में colon न हो तो वो set comprehension है — और duplicates अपने आप हट जाते हैं:

words = ["Apple", "apple", "BANANA", "banana"]

{w.lower() for w in words}        # {'apple', 'banana'} — unique, case-folded

students = {"class_a": {...}, "class_b": {...}}
{len(m) for m in students.values()}     # अलग-अलग sizes

# सबसे तेज़ dedup, अगर order नहीं चाहिए
unique_ids = {r["id"] for r in rows}

# order चाहिए तो
unique_ids = list(dict.fromkeys(r["id"] for r in rows))

🛠️ Practice करो (free, browser में)

पढ़ना काफी नहीं — यही bug खुद fix करके देखो। नीचे के problems browser में ही चलते हैं, कोई install नहीं, कोई login नहीं।

• Dictionary comprehension with condition — filter के साथ dict बनाना।
• Nested dictionary access — अंदरूनी dict तक पहुँचना।

अक्सर पूछे जाने वाले सवाल

आगे पढ़ो

• List comprehension Hindi में
• Python dictionary Hindi में
• Python set Hindi में
• Hindi hub — सारे Hindi guides