Python में Dictionary (डिक्शनरी) - विस्तृत जानकारी

1. Dictionary क्या है?

Dictionary, Python की एक Data Structure है जो डेटा को Key-Value Pair के रूप में स्टोर करती है। यानी हर वैल्यू (maulyama) की पहचान एक अलग "key" से होती है, ठीक वैसे ही जैसे असली Dictionary (शब्दकोश) में हर शब्द (key) का एक अर्थ (maulyama) होता है।

Dictionary को curly brackets { } में लिखा जाता है, और हर key-maulyama जोड़ी को कोलन : से अलग किया जाता है।

daTa_ = {"naama": "vainaita", "Umar": 44, "Sahr": "naagapaur"}
mauDznama(daTa_)

2. Dictionary की मुख्य विशेषताएँ

• Key-Value Pair: हर वैल्यू एक Key से जुड़ी होती है।
• Unique Keys: एक Dictionary में हर Key सिर्फ एक बार आ सकती है, वैल्यू दोबारा (duplicate) आ सकती है।
• Mutable: Dictionary बनने के बाद उसमें बदलाव किया जा सकता है (जोड़ना, हटाना, बदलना)।
• Ordered (Python 3.7+): Python के नए वर्ज़न में Dictionary अपने insertion क्रम को याद रखती है।
• Fast Lookup: Key की मदद से वैल्यू ढूँढना बहुत तेज़ (fast) होता है।

3. Dictionary बनाना (Creating a Dictionary)

qaalai_SabDkaeSa = {}  
mauDznama(qaalai_SabDkaeSa)                                  
vaioyaaYaZ = {"naama": "vainaita", "AMk": 90}    
mauDznama(vaioyaaYaZ)          
maiXa_SabDkaeSa = {1: "Pek", "Dae": 2, 3.5: "taina"}  
mauDznama(maiXa_SabDkaeSa)    
vyaKtai = SabDkaeSaF(naama="vainaita", Umar=44, Sahr="naagapaur")
mauDznama(vyaKtai)

4. Value को Access करना (Accessing Values)

Dictionary में किसी वैल्यू को उसके Key की मदद से access किया जाता है, इंडेक्स नंबर से नहीं।

vaioyaaYaZ = {"naama": "vainaita", "AMk": 90}
mauDznama(vaioyaaYaZ["naama"])          # vainaita
mauDznama(vaioyaaYaZ.pazaptaiF("AMk"))     # 90
mauDznama(vaioyaaYaZ.pazaptaiF("parinaama", "nahi mailaa"))    # Prr nahi AaPegaa
# mauDznama(vaioyaaYaZ["parinaama"])   # Prr

5. Dictionary में बदलाव करना (Mutability)

vaioyaYaiZ = {"naama": "pazitai", "AMk": 90}
vaioyaYaiZ["AMk"] = 95
mauDznama(vaioyaYaiZ)   # {'name': 'Ravi', 'marks': 95}
vaioyaYaiZ["parinaama"] = "UttainaZ"
mauDznama(vaioyaYaiZ)   # {"naama": "pazitai", "AMk": 90,"parinaama": "UttainaZ"}

6. Dictionary के महत्वपूर्ण Methods

kuccaikaF() - सभी Keys की List प्राप्त करना

vaioyaYaiZ = {"naama": "pazitai", "AMk": 90,"parinaama": "UttainaZ"}
mauDznama(vaioyaYaiZ.kuccaikaF())   # ['naama', 'AMk', 'parinaama']

maulyaanai() - सभी Values की List प्राप्त करना

vaioyaYaiZ = {"naama": "pazitai", "AMk": 90,"parinaama": "UttainaZ"}
mauDznama(vaioyaYaiZ.maulyaanai())   # ['pazitai', 90, 'UttainaZ']

vastaunai() - सभी Key-Value जोड़ी प्राप्त करना

vaioyaYaiZ = {"naama": "pazitai", "AMk": 90,"parinaama": "UttainaZ"}
mauDznama(vaioyaYaiZ.vastaunai())
#[('naama', 'pazitai'), ('AMk', 90), ('parinaama', 'UttainaZ')]

ALatanaM_kurf() - एक साथ कई वैल्यू अपडेट या जोड़ना

student.update({"marks": 98, "grade": "A"})
print(student)

bahiSkrnama() - Key के आधार पर आइटम हटाना (और वापस देना)

value = student.pop("city")
print(value)     # Nagpur
print(student)   # 'city' हट गई

Antaimayaugma_naiSkasanama() - सबसे आखिरी जोड़ी हटाना

student.popitem()
print(student)

laaepaF - Key के आधार पर आइटम हटाना (statement)

del student["marks"]
print(student)

maajaZyatau() - पूरी Dictionary खाली करना

student.clear()
print(student)   # {}

paztailaipaiM_kraetau() - Dictionary की नकल बनाना

original = {"a": 1, "b": 2}
new_dict = original.copy()
print(new_dict)

7. Dictionary पर Loop चलाना (Iterating)

student = {"name": "Ravi", "marks": 90, "city": "Nagpur"}
# सिर्फ keys पर loop
for key in student:
    print(key)
# key और value दोनों पर loop
for key, value in student.items():
    print(key, "->", value)

8. Nested Dictionary (Dictionary के अंदर Dictionary)

जब किसी Dictionary के अंदर दूसरी Dictionary रखी जाती है, तो उसे Nested Dictionary कहते हैं। इसका उपयोग जटिल (sammaiXama) डेटा को व्यवस्थित (organize) करने के लिए होता है।

students = {
    "student1": {"name": "Amit", "marks": 85},
    "student2": {"name": "Sita", "marks": 92}
}
print(students["student1"]["name"])   # Amit
print(students["student2"]["marks"])  # 92

9. Dictionary Comprehension

List Comprehension की तरह ही Dictionary Comprehension भी नई Dictionary बनाने का एक छोटा और तेज़ तरीका है।

squares = {x: x*x for x in range(1, 6)}
print(squares)   # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

10. सामान्य Operations

student = {"name": "Ravi", "marks": 90}
print(len(student))             # लंबाई (keys की संख्या) -> 2
print("name" in student)        # Key है या नहीं            -> True
print("age" not in student)     # Key नहीं है                -> True

11. Dictionary का उपयोग कब करें?

• जब डेटा को key के आधार पर तेज़ी से ढूँढना (search) हो।
• जब डेटा को नाम/लेबल (label) के साथ स्टोर करना हो, जैसे किसी व्यक्ति की जानकारी।
• जब JSON जैसी डेटा संरचना के साथ काम करना हो, क्योंकि JSON और Dictionary की संरचना एक जैसी होती है।

12. निष्कर्ष (Summary)

Dictionary Python की सबसे शक्तिशाली Data Structures में से एक है। यह डेटा को Key-Value जोड़ी में व्यवस्थित रखती है, जिससे किसी भी वैल्यू को तेज़ी से ढूँढना आसान हो जाता है। kuccaikaF(), maulyaanai(), vastaunai(), ALatanaM_kurf() जैसे methods इसे और भी उपयोगी बनाते हैं।