पायथन में ये तीनों अलग-अलग प्रकार की डेटा संरचनाएं हैं। इसका उपयोग डेटा के विभिन्न संग्रहों को संग्रहीत करने के लिए किया जाता है। हमारी आवश्यकता के उपयोग के आधार पर, हमें इनमें से एक को चुनना होगा।

शब्दकोश (dict):

1. शब्दकोश कुंजी मान युग्म का संग्रह है, जहां प्रत्येक कुंजी एक मान से जुड़ी होती है
2. कुंजी मान (कुंजी आधारित खोज) के आधार पर डेटा पुनर्प्राप्त किया जा सकता है क्योंकि कुंजियों का अद्वितीय होना आवश्यक है।
3. शब्दकोश 3.7 तक अव्यवस्थित हैं, मान बदले जा सकते हैं। कुंजी का नाम सीधे नहीं बदला जा सकता

सिंटैक्स:
सूची = {'सेब':20, 'केला':30, 'गाजर':15, 'दूध':15}
प्रिंट('\t1. इन्वेंटरी आइटम', इन्वेंट्री)

शब्दकोशों को किसी अन्य मूल्य के साथ जोड़ा जा सकता है/नीचे दिए गए सिंटैक्स का उपयोग करके मौजूदा कुंजी के मूल्य को संशोधित किया जा सकता है

इन्वेंटरी['अंडा'] = 20
इन्वेंटरी['ब्रेड'] = 25
प्रिंट('\t2. अद्यतन इन्वेंटरी आइटम', इन्वेंट्री)
सूची['अंडा']= सूची['अंडा'] 5
प्रिंट करें ('\t3. पुनः स्टॉक करने के बाद', इन्वेंट्री)

• डिक्ट से डेटा को हटाने का काम डेल कीवर्ड का उपयोग करके किया जा सकता है।
• डेटा की उपस्थिति की जांच इन कीवर्ड का उपयोग करके की जा सकती है। परिणाम बूलियन होगा.

डेल इन्वेंटरी['गाजर']
डेल इन्वेंटरी['ब्रेड']
प्रिंट('\t4. डिलीट के बाद अपडेट की गई इन्वेंटरी', इन्वेंट्री)

is_bananas_in_inventory = इन्वेंट्री में 'केला'
प्रिंट('\t5a. क्या केला इन्वेंट्री में है', is_bananas_in_inventory)
is_oranges_in_inventory = इन्वेंट्री में 'नारंगी'
print('\t5b. क्या ऑरेंज इन्वेंट्री में है', is_oranges_in_inventory)

नोट्स:
अतिरिक्त dict.items() प्रत्येक आइटम को शब्दकोश में टुपल (कुंजी मान जोड़ी की तरह) के रूप में देगा। list(dict.items()) का उपयोग करके हम डेटा को सूची के रूप में भी प्राप्त कर सकते हैं। लूप के लिए और यदि स्थिति का उपयोग करके, हम विशेष कुंजी तक पहुंच सकते हैं और उस डेटा के लिए वांछित ऑपरेशन कर सकते हैं

for product, product_count in inventory.items():
    print('\t\t6. Product:', product, 'count is:', product_count)
print ('\t7. Iterating inventory gives tuple:', inventory.items())

#Printing only egg count(Value of key 'egg') by itearting dict
for product, product_count in inventory.items():
    if product is 'egg':
        print('\t8. Product:', product, ' its count is:', product_count)

#Printing egg count (value of key 'egg')
print('\t9. Count of apple',inventory['egg'])

Output:
        1. Inventory items {'apple': 20, 'Banana': 30, 'carrot': 15, 'milk': 15}
        2. Updated Inventory items {'apple': 20, 'Banana': 30, 'carrot': 15, 'milk': 15, 'egg': 20, 'bread': 25}
        3. After restocking {'apple': 30, 'Banana': 30, 'carrot': 15, 'milk': 15, 'egg': 25, 'bread': 25}
        4. Updated Inventory after delete {'apple': 30, 'Banana': 30, 'milk': 15, 'egg': 25}
        5a. Is banana in inventory True
        5b. Is Orange in inventory False
                6. Product: apple count is: 30
                6. Product: Banana count is: 30
                6. Product: milk count is: 15
                6. Product: egg count is: 25
        7. Iterating inventory gives tuple: dict_items([('apple', 30), ('Banana', 30), ('milk', 15), ('egg', 25)])
        8. Product: egg  its count is: 25
        9. Count of apple 25

तय करना:
समुच्चय अद्वितीय तत्वों का एक अव्यवस्थित संग्रह है। सेट परिवर्तनशील हैं, लेकिन वे डुप्लिकेट तत्वों की अनुमति नहीं देते हैं।

सिंटैक्स:
वानस्पतिक_उद्यान = {'गुलाब', 'कमल', 'लिली'}
botanical_garden.add('जैस्मीन')
botanical_garden.remove('गुलाब')
is_present_Jasmin = वनस्पति उद्यान में 'जैस्मीन'

ऊपर हम एक सेट को परिभाषित करना, एक मान जोड़ना और उसे हटाना देख सकते हैं। यदि हम एक सेट में समान तत्व जोड़ते हैं, तो यह एक त्रुटि उत्पन्न करेगा।

इसके अलावा हम वेन आरेख के समान दो सेटों की तुलना भी कर सकते हैं। जैसे संघ, अंतर, दो डेटा सेटों का प्रतिच्छेदन।

botanical_garden = {'Tuple', 'rose', 'Lily', 'Jasmine', 'lotus'}
rose_garden = {'rose', 'lotus', 'Hybiscus'}

common_flower= botanical_garden.intersection(rose_garden)
flowers_only_in_bg = botanical_garden.difference(rose_garden)
flowers_in_both_set = botanical_garden.union(rose_garden)

Output will be a set by default. 
If needed we can typecase into list using list(expression)

ट्यूपल:
टुपल तत्वों का एक व्यवस्थित संग्रह है जो अपरिवर्तनीय है, जिसका अर्थ है कि इसे बनने के बाद बदला नहीं जा सकता है।

सिंटैक्स:

ooty_trip = ('Ooty', '2024-1-1', 'Botanical_Garden')
munnar_trip = ('Munar', '2024-06-06', 'Eravikulam National Park')
germany_trip = ('Germany', '2025-1-1', 'Lueneburg')
print('\t1. Trip details', ooty_trip, germany_trip)

#Accessing tuple using index
location = ooty_trip[0]
date = ooty_trip[1]
place = ooty_trip[2]

print(f'\t2a. Location: {location} Date: {date} Place: {place} ')

location, date, place =germany_trip # Assinging a tuple to 3 different variables
print(f'\t2b. Location: {location} Date: {date} Place: {place} ')

print('\t3. The count of ooty_trip is ',ooty_trip.count)

Output:
   1. Trip details ('Ooty', '2024-1-1', 'Botanical_Garden') ('Germany', '2025-1-1', 'Lueneburg')
   2a. Location: Ooty Date: 2024-1-1 Place: Botanical_Garden
   2b. Location: Germany Date: 2025-1-1 Place: Lueneburg
   3. The count of ooty_trip is  

टुपल्स को इंडेक्स का उपयोग करके एक्सेस किया जा सकता है। टुपल्स के मानों को आसानी से कई वेरिएबल्स को सौंपा जा सकता है। हम दो टुपल्स को जोड़ सकते हैं जिससे एक और टुपल बनेगा। लेकिन टुपल को संशोधित नहीं किया जा सकता।