पायथन डिक्शनरी और DRY सिद्धांत: शुरुआती लोगों के लिए एक त्वरित मार्गदर्शिका

सुनो! ? यदि आप पाइथॉन प्रोग्रामिंग में गोता लगा रहे हैं, तो संभवतः आपने शब्दकोशों पर ठोकर खाई होगी और शायद सोचा होगा, "पायथन में एक शब्दकोश वास्तव में क्या है, और यह मुझे बेहतर तरीके से कोड करने में कैसे मदद कर सकता है?" कोई चिंता नहीं आइए इसे बहुत ही सरल तरीके से तोड़ें।

पायथन में शब्दकोश क्या है?

कल्पना करें कि आपके पास वस्तुओं की एक सूची है, और प्रत्येक वस्तु के साथ एक अद्वितीय लेबल जुड़ा हुआ है, जैसे "नाम: जॉन" या "उम्र: 25"। पायथन में एक शब्दकोश बिल्कुल उसी तरह काम करता है! यह कुंजी मान जोड़े का एक संग्रह है, जहां प्रत्येक कुंजी अद्वितीय है और एक विशिष्ट मान को इंगित करती है। इसे साफ-सुथरे और व्यवस्थित तरीके से जानकारी संग्रहीत करने के लिए एक मिनी डेटाबेस के रूप में सोचें।

यह एक वास्तविक शब्दकोश की तरह है जहां आप एक शब्द (कुंजी) देखते हैं और उसका अर्थ (मूल्य) प्राप्त करते हैं। बढ़िया, है ना? ?

पायथन में एक शब्दकोश कैसे बनाएं?

शब्दकोश बनाना पाई जितना आसान है। आप बस घुंघराले ब्रेसिज़ {} का उपयोग करें और प्रत्येक कुंजी मान जोड़ी को कोलन से अलग करें :.

यहां बताया गया है कि आप एक सरल शब्दकोश कैसे बना सकते हैं:

# Creating a dictionary to store student information
student_info = {
    'name': 'John Doe',
    'age': 21,
    'major': 'Computer Science'
}

# Printing out the dictionary
print(student_info)

यह शब्दकोश छात्र का नाम, उम्र और प्रमुख जानकारी संग्रहीत करता है। ध्यान दें कि 'नाम' और 'उम्र' जैसी कुंजियाँ उद्धरण चिह्नों में कैसी हैं? ऐसा इसलिए है क्योंकि कुंजियाँ स्ट्रिंग, संख्याएँ या टुपल्स भी हो सकती हैं! मान कुछ भी हो सकते हैं, स्ट्रिंग्स, सूचियाँ, अन्य शब्दकोश, आप इसे नाम दें।

शब्दकोश हमें दोहराव से बचने में कैसे मदद करते हैं (DRY सिद्धांत)

अब, यहीं पर यह दिलचस्प हो जाता है। आपने DRY सिद्धांत के बारे में सुना होगा, जिसका मतलब है डोंट रिपीट योरसेल्फ। यह एक नियम है जो आपको अपने कोड में अतिरेक से बचने के लिए प्रोत्साहित करता है। शब्दकोश इसमें कैसे मदद कर सकते हैं? चलो एक नज़र मारें।

किसी शब्दकोश का उपयोग करने से पहले (दोहराया जाने वाला कोड)

कल्पना करें कि आप छात्रों के बारे में जानकारी अलग-अलग चर में संग्रहीत करना चाहते हैं। यह कुछ इस तरह दिख सकता है:

student1_name = 'Alice'
student1_age = 20
student1_major = 'Mathematics'

student2_name = 'Bob'
student2_age = 22
student2_major = 'Physics'

हमारे पास न केवल दोहराए जाने वाले चर नाम हैं, बल्कि अगर हम इन्हें प्रिंट या अपडेट करना चाहते हैं, तो हमें खुद को बार-बार दोहराना होगा। यह वह जगह है जहां शब्दकोश दिन बचा सकते हैं! ?

उदाहरण 1: एक शब्दकोश का उपयोग करने के बाद (DRY संस्करण)

शब्दकोशों के साथ, हम यह सारी जानकारी साफ़-सुथरे तरीके से संग्रहीत कर सकते हैं:

# Using dictionaries to store student data
students = {
    'student1': {'name': 'Alice', 'age': 20, 'major': 'Mathematics'},
    'student2': {'name': 'Bob', 'age': 22, 'major': 'Physics'}
}

print(students['student1']['name'])  # Output: Alice
print(students['student2']['age'])   # Output: 22

अब, आपको प्रत्येक छात्र के नाम, आयु और प्रमुख के लिए अलग-अलग चर बनाने की ज़रूरत नहीं है। आप बहुत सरल तरीके से जानकारी तक पहुंच सकते हैं या उसे अपडेट कर सकते हैं। साथ ही, यह आपके कोड को साफ़-सुथरा और प्रबंधित करना आसान बनाता है।

उदाहरण 2: शब्दकोशों के साथ दोहराव से बचना

मान लीजिए कि आप छात्र अंकों के आधार पर एक सरल ग्रेडिंग प्रणाली बनाना चाहते हैं। शब्दकोशों के बिना, आप निम्नलिखित लिखना समाप्त कर सकते हैं:

# Without dictionary (repeating code)
alice_score = 90
bob_score = 75
charlie_score = 85

if alice_score >= 85:
    print("Alice gets an A")
if bob_score >= 85:
    print("Bob gets an A")
if charlie_score >= 85:
    print("Charlie gets an A")

यहां, हम if कथनों को दोहरा रहे हैं और प्रत्येक छात्र के नाम और स्कोर को हार्डकोड कर रहे हैं, जो DRY सिद्धांत का उल्लंघन करता है।

इसके बजाय, एक शब्दकोश के साथ, आप इस तरह दोहराव से बच सकते हैं:

# Using a dictionary (DRY principle)
student_scores = {'Alice': 90, 'Bob': 75, 'Charlie': 85}

for student, score in student_scores.items():
    if score >= 85:
        print(f"{student} gets an A")

अब, आपके पास एक साफ़, छोटा और अधिक रखरखाव योग्य कोड है! आप यदि कथन केवल एक बार लिखते हैं, और यह आपके शब्दकोश के सभी छात्रों के लिए काम करता है। ?

उपयोगी शब्दकोश विधियां

शब्दकोश कई अंतर्निहित तरीकों के साथ आते हैं जो उनके साथ काम करना आसान बनाते हैं। आइए उनमें से कुछ पर नज़र डालें:

1. .get(): यदि कुंजी मौजूद नहीं है तो त्रुटियों से बचने में आपकी सहायता करता है।

   print(student_info.get('address', 'Address not available'))  
   # Output: Address not available

1. .keys() और .values(): शब्दकोश में सभी कुंजियाँ या मान प्राप्त करें।

   print(student_info.keys())  # Output: dict_keys(['name', 'age', 'major'])
   print(student_info.values())  # Output: dict_values(['John Doe', 21, 'Computer Science'])

1. .items(): दोनों कुंजियाँ और मान जोड़े के रूप में प्राप्त करें।

   for key, value in student_info.items():
       print(f'{key}: {value}')
   # Output: 
   # name: John Doe
   # age: 21
   # major: Computer Science

1. .update(): किसी शब्दकोश को किसी अन्य शब्दकोश या कुंजी-मूल्य जोड़े के साथ अपडेट करें।

   student_info.update({'grade': 'A'})
   print(student_info)  
   # Output: {'name': 'John Doe', 'age': 21, 'major': 'Computer Science', 'grade': 'A'}

1. .setdefault(): यदि कुंजी मौजूद नहीं है तो डिफ़ॉल्ट मान के साथ एक कुंजी जोड़ता है।

   student_info.setdefault('graduation_year', 2024)
   print(student_info)  
   # Output: {'name': 'John Doe', 'age': 21, 'major': 'Computer Science', 'grade': 'A', 'graduation_year': 2024}

ऊपर लपेटकर

शब्दकोश अत्यंत शक्तिशाली हैं और वास्तव में आपके कोड में DRY सिद्धांत का पालन करने में आपकी सहायता कर सकते हैं। शब्दकोशों का उपयोग करके, आप खुद को दोहराने से बचते हैं, अपना कोड व्यवस्थित रखते हैं, और इसे पढ़ना और बनाए रखना आसान बनाते हैं।

तो, अगली बार जब आप खुद को समान चर का एक समूह बनाते हुए पाएं, तो इसके बजाय एक शब्दकोश का उपयोग करने पर विचार करें। इससे आपका ढेर सारा समय और प्रयास बचेगा और आपका भविष्य स्वयं आपको धन्यवाद देगा! ?

हैप्पी कोडिंग! ?