पाइथन डिक्शनरी — Study Notes

1. परिचय

डिक्शनरी (Dictionary) पाइथन का एक म्यूटेबल (परिवर्तनीय), अक्रमबद्ध (Unordered) डेटा प्रकार है जो कुंजी-मान युग्मों (Key-Value Pairs) को संग्रहीत करता है। डिक्शनरी को घुंघराले कोष्ठक {} में लिखा जाता है और कुंजी-मान युग्म को कोलन : से अलग किया जाता है। डिक्शनरी की कुंजियाँ अद्वितीय (Unique) होती हैं, अर्थात एक ही कुंजी दो बार नहीं आ सकती। कुंजियाँ इम्यूटेबल प्रकार की होनी चाहिए (जैसे str, int, tuple), जबकि मान किसी भी प्रकार के हो सकते हैं। डिक्शनरी की सबसे बड़ी विशेषता यह है कि कुंजी के आधार पर मान को बहुत तेज़ी से प्राप्त किया जा सकता है। इस अध्याय में हम डिक्शनरी के निर्माण, एक्सेस, मेथड, ट्रैवर्सल और उपयोगों का विस्तृत अध्ययन करेंगे।

2. डिक्शनरी का निर्माण

डिक्शनरी को अनेक विधियों से बनाया जा सकता है:

d1 = {"नाम": "राहुल", "उम्र": 16, "कक्षा": 11}
d2 = {1: "एक", 2: "दो", 3: "तीन"}
d3 = {}
d4 = dict([("a", 1), ("b", 2)])

• {} खाली डिक्शनरी बनाता है।
• dict() फ़ंक्शन द्वारा भी डिक्शनरी बनाई जा सकती है।

मान किसी भी प्रकार के हो सकते हैं

d = {"सूची": [1, 2, 3], "संख्या": 10, "तार्किक": True}

कुंजी-मान युग्म नियम

1. कुंजियाँ अद्वितीय होनी चाहिए।
2. कुंजियाँ इम्यूटेबल (str, int, tuple) होनी चाहिए।
3. यदि कुंजी दोहराई जाए, तो नया मान पुराने को बदल देता है।

d = {"a": 1, "a": 2}
print(d)

आउटपुट: {'a': 2}

3. मान तक पहुँच (Accessing)

कुंजी के माध्यम से मान प्राप्त किया जाता है।

d = {"नाम": "राहुल", "उम्र": 16}
print(d["नाम"])
print(d["उम्र"])

• d["नाम"] = 'राहुल'

यदि कुंजी मौजूद नहीं है, तो KeyError आती है। इससे बचने के लिए get() मेथड उपयोगी है।

d = {"नाम": "राहुल"}
print(d.get("उम्र"))
print(d.get("उम्र", "उपलब्ध नहीं"))

• d.get("उम्र") = None (त्रुटि नहीं)
• d.get("उम्र", "उपलब्ध नहीं") = 'उपलब्ध नहीं' (डिफ़ॉल्ट मान)

4. डिक्शनरी मेथड

मान जोड़ना और बदलना

d = {"नाम": "राहुल"}
d["उम्र"] = 16
d["नाम"] = "सीमा"
print(d)

नई कुंजी देने पर युग्म जुड़ता है और मौजूदा कुंजी का मान बदल जाता है।

keys(), values(), items()

d = {"a": 1, "b": 2, "c": 3}
print(d.keys())
print(d.values())
print(d.items())

• keys() = dict_keys(['a', 'b', 'c'])
• values() = dict_values([1, 2, 3])
• items() = dict_items([('a', 1), ('b', 2), ('c', 3)])

update() मेथड

एक डिक्शनरी के युग्म दूसरी में जोड़ना:

d1 = {"a": 1}
d2 = {"b": 2, "c": 3}
d1.update(d2)
print(d1)

आउटपुट: {'a': 1, 'b': 2, 'c': 3}

pop() और popitem()

• pop(key) - दी गई कुंजी का युग्म हटाकर मान लौटाता है।
• popitem() - अंतिम युग्म हटाकर उसे लौटाता है (पाइथन 3.7+ में)।

d = {"a": 1, "b": 2, "c": 3}
x = d.pop("b")
print(x, d)

• pop("b") = 2, शेष d = {'a': 1, 'c': 3}

clear() और copy()

• clear() - सभी युग्म हटा देता है।
• copy() - डिक्शनरी की प्रतिलिपि बनाता है।

len() और in ऑपरेटर

d = {"a": 1, "b": 2}
print(len(d))
print("a" in d)
print("c" in d)

• len(d) = 2, "a" in d = True, "c" in d = False

5. डिक्शनरी ट्रैवर्सल (Traversal)

डिक्शनरी पर लूप चलाकर प्रत्येक कुंजी-मान युग्म को प्राप्त किया जा सकता है।

d = {"नाम": "राहुल", "उम्र": 16, "शहर": "दिल्ली"}
for key in d:
    print(key, ":", d[key])

for k, v in d.items():
    print(k, "-", v)

पहला लूप कुंजियों को और दूसरा कुंजी-मान दोनों को प्रिंट करता है।

कुंजी/मान केवल प्रिंट करना

for k in d.keys():
    print(k)
for v in d.values():
    print(v)

कुंजियों को क्रमबद्ध करना

d = {"c": 3, "a": 1, "b": 2}
for k in sorted(d):
    print(k, d[k])

6. नेस्टेड डिक्शनरी

डिक्शनरी के मान फिर से डिक्शनरी हो सकते हैं, जिन्हें नेस्टेड डिक्शनरी कहते हैं।

students = {
    "101": {"नाम": "राहुल", "अंक": 85},
    "102": {"नाम": "सीमा", "अंक": 92}
}
print(students["101"]["नाम"])
print(students["102"]["अंक"])

• students["101"]["नाम"] = 'राहुल'
• students["102"]["अंक"] = 92

7. डिक्शनरी को क्रमबद्ध करना

डिक्शनरी स्वयं अक्रमबद्ध (Unordered) होती है, परंतु हम उसके कुंजियों या मानों को sorted() फ़ंक्शन द्वारा क्रमबद्ध कर सकते हैं। sorted(d) डिक्शनरी की कुंजियों को क्रमबद्ध सूची के रूप में लौटाता है। यदि हमें कुंजियों के क्रम में युग्मों को प्रिंट करना हो, तो हम sorted कुंजियों पर लूप चलाकर प्रत्येक कुंजी का मान प्राप्त कर सकते हैं। इसी प्रकार sorted(d.values()) से मानों को क्रमबद्ध किया जा सकता है। वास्तविक जीवन में डिक्शनरी का उपयोग अनेक प्रकार के डेटा को व्यवस्थित करने के लिए होता है, जैसे विद्यार्थियों का रोल नंबर से नाम, विषय कोड से विषय का नाम, देश की राजधानियाँ, वस्तुओं की कीमतें, और शब्दकोश में शब्द और उनके अर्थ। इन सभी में कुंजी के द्वारा मान तक तीव्र गति से पहुँचा जा सकता है, जो सूची से कहीं अधिक कुशल होता है। डिक्शनरी की इसी विशेषता के कारण इसे 'सहयोगी सरणी' (Associative Array) भी कहा जाता है।

8. डिक्शनरी के उन्नत उपयोग

डिक्शनरी को डिफ़ॉल्ट मान के साथ प्रारंभ करना

get() मेथड के साथ डिफ़ॉल्ट मान देकर हम कोड को छोटा और सुरक्षित बना सकते हैं। उदाहरण के लिए, किसी शब्द में वर्णों की गिनती करने के लिए हमें पहले यह जाँचने की आवश्यकता नहीं होती कि वर्ण पहले से मौजूद है या नहीं, बल्कि get(ch, 0) स्वयं ही अनुपस्थिति पर 0 मान लेता है। यह पैटर्न डेटा विश्लेषण, फ़्रीक्वेंसी गिनती और रिपोर्ट निर्माण में अत्यंत उपयोगी है। इसी प्रकार, नेस्टेड डिक्शनरी में एक डिक्शनरी के भीतर दूसरी डिक्शनरी को संग्रहीत करके जटिल डेटा, जैसे वर्ग का संपूर्ण विवरण, आसानी से प्रबंधित किया जा सकता है। किसी भी स्तर पर पहुँचने के लिए कुंजियों की श्रृंखला लिखी जाती है, जैसे students["101"]["विषय"]["अंक"]। डिक्शनरी की म्यूटेबल प्रकृति के कारण हम इन मानों को बदल सकते हैं, नए युग्म जोड़ सकते हैं और अनुपयोगी युग्मों को pop() या popitem() से हटा सकते हैं। update() मेथड से एक डिक्शनरी के सभी युग्मों को दूसरी में विलय किया जा सकता है, जो दो अलग-अलग स्रोतों से डेटा जोड़ने में सहायक है। in ऑपरेटर से कुंजी की उपस्थिति जाँची जा सकती है, जो डेटा में खोज के लिए उपयोगी है। len() से डिक्शनरी के आकार (युग्मों की संख्या) का पता चलता है। इस प्रकार डिक्शनरी के मेथड और ऑपरेटर मिलकर डेटा प्रबंधन का एक संपूर्ण समाधान प्रस्तुत करते हैं। परीक्षा में डिक्शनरी से जुड़े प्रश्न मुख्यतः keys, values, items, get, update, pop और ट्रैवर्सल पर आधारित होते हैं, इसलिए इनका अभ्यास करना अत्यंत आवश्यक है।

9. डिक्शनरी के प्रमुख उपयोग

वर्णों की गिनती

word = "abracadabra"
count = {}
for ch in word:
    count[ch] = count.get(ch, 0) + 1
print(count)

इससे प्रत्येक वर्ण की संख्या प्राप्त होती है।

सामान्य उपयोग

• शब्दकोश (शब्द और अर्थ)
• छात्र रिकॉर्ड (रोल नंबर और नाम)
• संख्या का शब्दों में मानचित्रण
• फ़्रीक्वेंसी गिनती

8. डिक्शनरी की सामान्य त्रुटियाँ

• KeyError: गलत/अनुपस्थित कुंजी से मान लेने पर।
• कुंजी दोहराना: दोहरी कुंजी पर पुराना मान मिट जाता है।
• म्यूटेबल कुंजी: लिस्ट को कुंजी नहीं बनाया जा सकता (TypeError)।
• = से प्रतिलिपि: b = d दोनों एक ही डिक्शनरी को संदर्भित करते हैं; copy() उपयोग करें।

d = {}
d[[1, 2]] = "गलत"

यह TypeError देगा क्योंकि लिस्ट म्यूटेबल है और कुंजी इम्यूटेबल होनी चाहिए।

graph TD
    A["डिक्शनरी"] --> B["कुंजी-मान युग्म"]
    A --> C["निर्माण: {}, dict()"]
    A --> D["एक्सेस: d[key], get()"]
    A --> E["मेथड"]
    E --> F["keys, values, items"]
    E --> G["update, pop, popitem"]
    E --> H["clear, copy"]
    A --> I["ट्रैवर्सल: for लूप"]
    A --> J["नेस्टेड डिक्शनरी"]
    B --> K["कुंजी इम्यूटेबल, अद्वितीय"]

त्वरित पुनरावृत्ति तालिकाएँ

मेथड	कार्य	उदाहरण
d.keys()	सभी कुंजियाँ	d.keys()
d.values()	सभी मान	d.values()
d.items()	सभी युग्म	d.items()
d.get(k)	मान (त्रुटि रहित)	d.get("a")
d.update(d2)	युग्म जोड़ना	d1.update(d2)
d.pop(k)	युग्म हटाना	d.pop("a")
d.clear()	सभी हटाना	d.clear()
d.copy()	प्रतिलिपि	d2 = d.copy()
len(d)	युग्मों की संख्या	len(d)

संचालन	परिणाम
{"a": 1}	कुंजी 'a', मान 1
d["नई"] = 5	नया युग्म जोड़ना
"a" in d	True (यदि कुंजी है)
len({"a":1,"b":2})	2
list(d.keys())	['a', 'b']

माइंड मैप

flowchart TD
    A["पाइथन डिक्शनरी"] --> B["कुंजी-मान युग्म"]
    A --> C["निर्माण"]
    A --> D["एक्सेस"]
    A --> E["मेथड"]
    A --> F["ट्रैवर्सल"]
    B --> G["कुंजी: इम्यूटेबल, अद्वितीय"]
    D --> H["d[key], get(), in"]
    E --> I["keys, values, items"]
    E --> J["update, pop, clear"]
    F --> K["for k, v in d.items()"]
    A --> L["नेस्टेड डिक्शनरी"]
    A --> M["फ़्रीक्वेंसी गिनती"]

महत्वपूर्ण आरेख (SVG)

सामान्य गलतियाँ

1. अनुपस्थित कुंजी से मान लेना: d["अज्ञात"] पर KeyError आती है; get() से बचाव करें।
2. म्यूटेबल कुंजी का उपयोग: लिस्ट को कुंजी बनाना TypeError देता है; कुंजी इम्यूटेबल (str, int, tuple) होनी चाहिए।
3. कुंजी दोहराना: दोहरी कुंजी लिखने पर पुराना मान नए से बदल जाता है - यह नई कुंजी नहीं बनाता।
4. items() की अनदेखी: ट्रैवर्सल में केवल d से लूप चलाने पर कुंजियाँ मिलती हैं, मान के लिए d[key] या items() चाहिए।
5. b = d को प्रतिलिपि समझना: दोनों एक ही डिक्शनरी को संदर्भित करते हैं; स्वतंत्र प्रतिलिपि के लिए copy()।
6. pop() के बिना इंडेक्स की अपेक्षा: डिक्शनरी इंडेक्स (0,1,2...) द्वारा एक्सेस नहीं होती, केवल कुंजी से।
7. len() का गलत अर्थ: len(d) युग्मों की संख्या देता है, न कि सभी मानों का योग।

परीक्षा युक्तियाँ

1. keys(), values(), items() के उदाहरण और उनके आउटपुट अवश्य याद रखें।
2. get() बनाम d[key] का अंतर - get() अनुपस्थित कुंजी पर KeyError नहीं देता।
3. वर्ण फ़्रीक्वेंसी गिनती का प्रोग्राम लिखना सीखें: count[ch] = count.get(ch, 0) + 1।
4. नेस्टेड डिक्शनरी (रोल नंबर → विवरण) के उदाहरण पर अभ्यास करें।
5. कुंजी अद्वितीय और इम्यूटेबल होती है - यह तथ्य अक्सर परीक्षा में पूछा जाता है।
6. for k, v in d.items() ट्रैवर्सल का मानक रूप याद रखें।
7. update() से एक डिक्शनरी को दूसरी में विलय करना जानें।

निष्कर्ष

डिक्शनरी पाइथन का अत्यंत शक्तिशाली डेटा प्रकार है जो डेटा को कुंजी-मान युग्मों के रूप में व्यवस्थित करता है। इसकी तीव्र पहुँच क्षमता और लचीलापन इसे रिकॉर्ड प्रबंधन और डेटा विश्लेषण के लिए आदर्श बनाता है। कुंजी की अद्वितीयता और इम्यूटेबलता को सदैव ध्यान रखना चाहिए। get(), items(), update() जैसे मेथड कोड को सरल और त्रुटि-रहित बनाते हैं। अगले अध्याय में हम matplotlib के माध्यम से डेटा विज़ुअलाइज़ेशन का अध्ययन करेंगे, जहाँ डेटा प्रकारों की यह समझ सीधे उपयोग होगी। छात्रों को डिक्शनरी पर आधारित अभ्यास प्रोग्राम, जैसे छात्र रिकॉर्ड और शब्द गिनती, स्वयं लिखने चाहिए।