पायथन डेटा संरचनाएं

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

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

इस लेख में, हम पाइथन द्वारा पेश की जाने वाली अंतर्निहित डेटा संरचनाओं में गोता लगाते हैं।

पायथन में अंतर्निहित डेटा संरचनाएं

पायथन में अंतर्निहित डेटा संरचनाओं में सूचियाँ, शब्दकोश, टुपल्स और सेट शामिल हैं।

सूचियां

सूचियाँ परिवर्तनशील (परिवर्तन करने में सक्षम) डेटा संरचनाएँ हैं जिनमें भिन्न तत्व या भाग हो सकते हैं। दूसरे शब्दों में, एक सूची में विभिन्न प्रकार के डेटा हो सकते हैं।

 सूची =['स्ट्रिंग', 300, (2, 4), 'वह पिछला डेटा प्रकार एक टपल था']

सूची डेटा संरचना में सूची को जोड़ने, हटाने या हेरफेर करने के लिए 11 विधियों का उपयोग किया जाता है।

तत्वों को सूची में जोड़ना

• एपेंड ():एपेंड () विधि एक सूची में एक आइटम जोड़ती है

 सूची =['स्ट्रिंग, अगला टुपेल है', (2, 1), 3] सूची। संलग्न करें (500) प्रिंट (सूची) # प्रिंट ['स्ट्रिंग, अगला टुपेल है', (2, 1), 3 , 500]

• विस्तार ():विस्तार () विधि पुनरावर्तनीय से सभी वस्तुओं द्वारा सूची को जोड़ती है। यह निम्नलिखित तरीके से एपेंड () से अलग है।

सूची =['स्ट्रिंग, अगला टुपेल है', (2, 1), 3] सूची। संलग्न करें ((8, 9)) प्रिंट (सूची) # प्रिंट ['स्ट्रिंग, अगला टुपेल है', (2, 1), 3, (8, 9)] # ध्यान दें कि संलग्न () एक टपल के रूप में (8, 9) छोड़ दें 

सूची =['स्ट्रिंग, अगला टुपेल है', (2, 1), 3] सूची। विस्तार ((8, 9)) प्रिंट (सूची) # प्रिंट ['स्ट्रिंग, अगला टुपेल है', (2, 1), 3, 8, 9] # ध्यान दें कि विस्तार () ने टपल के रूप में (8, 9) नहीं छोड़ा

• insert():इन्सर्ट () मेथड किसी दिए गए पोजीशन या इंडेक्स पर एक आइटम को इंसर्ट करता है। पहला तर्क तत्व की अनुक्रमणिका है जिसे सम्मिलित करने की आवश्यकता है, दूसरा तर्क तत्व ही है।

 सूची =['स्ट्रिंग, अगला टुपेल है', (2, 1), 3] सूची। सम्मिलित करें (0, 700) प्रिंट (सूची) # प्रिंट [700, 'स्ट्रिंग, अगला टुपेल है', (2, 1), 3]# 0 इंडेक्स में 700 डाला गया

किसी सूची से तत्वों को हटाना

• निकालें ():निकालें () विधि सूची में पहले आइटम को हटा देती है जिसमें वह मान दिया गया था।

 list =['string, next is tupel', (2, 1), 3, 8, 3] list.remove(3) Print(list) # Prints ['string, next is tupel', (2, 1), 8, 3]

• pop ():पॉप () विधि दी गई स्थिति में एक मान को हटा देती है, हालांकि यदि कोई अनुक्रमणिका नहीं दी जाती है, तो यह अंतिम आइटम को हटा देती है।

 सूची =['स्ट्रिंग, अगला टुपेल है', (2, 1), 3] सूची। पॉप (0) प्रिंट (सूची) # प्रिंट [(2, 1), 3]

 लिस्ट =['स्ट्रिंग, नेक्स्ट इज टुपेल', (2, 1), 3] लिस्ट.पॉप () प्रिंट (लिस्ट) # प्रिंट्स ['स्ट्रिंग, नेक्स्ट इज टुपेल', (2, 1)]  
 
स्पष्ट ():स्पष्ट () विधि कोई तर्क नहीं लेती है। यह सूची से सभी आइटम हटा देता है।
 
 
 list =['string, next is tupel', (2, 1), 3] list.clear() Print(list) # Prints []
 
अन्य सूची विधियां
 
 
इंडेक्स ():इंडेक्स () मेथड दिए गए वैल्यू का इंडेक्स लौटाता है।
 
 
 सूची =[8, 20, 1, 9, 2, 3, 937, 0] प्रिंट (list.index(9)) # प्रिंट 3 
 
 
गिनती ():गिनती () विधि यह गिनती है कि किसी सूची में कोई मान कितनी बार आता है।
 
 
 सूची =[8, 20, 1, 8, 2, 8, 937, 8] प्रिंट (सूची। गिनती (8)) # प्रिंट 4
 
 
सॉर्ट ():सॉर्ट () पद्धति का उपयोग तर्कों के साथ या बिना तर्क के किया जा सकता है और अनुकूलन को सॉर्ट करने के लिए उपयोग किया जा सकता है।
 
 
 सूची =[8, 20, 1, 9, 2, 3, 937, 0] सूची। सॉर्ट () प्रिंट (सूची) # प्रिंट [0, 1, 2, 3, 8, 9, 20, 937] 
 
 सूची =[8, 20, 1, 9, 2, 3, 937, 0] सूची। सॉर्ट (रिवर्स =ट्रू) प्रिंट (सूची) # प्रिंट [937, 20, 9, 8, 3, 2, 1 , 0]
 
 
reverse():रिवर्स मेथड लिस्ट के एलिमेंट्स को जगह में उलट देता है, ठीक उसी तरह जैसे ऊपर सॉर्ट मेथड में कस्टमाइज्ड सॉर्टिंग तर्क होता है।
 
 
 सूची =[8, 20, 1, 9, 2, 3, 937, 0] सूची। रिवर्स () प्रिंट (सूची) # प्रिंट [0, 937, 3, 2, 9, 1, 20, 8] 
 
 
प्रतिलिपि ():प्रतिलिपि () विधि केवल एक सूची की एक प्रति लौटाती है।
 
 
 सूची =[8, 20, 1, 9, 2, 3, 937, 0] सूची। कॉपी () प्रिंट (सूची) # प्रिंट [8, 20, 1, 9, 2, 3, 937, 0] 
 
टुपल्स
 

 टुपल्स कोष्ठक में रखे गए डेटा हैं। सूचियों के विपरीत, वे परिवर्तनशील नहीं हैं (जिसका अर्थ है कि यह परिवर्तन करने में सक्षम नहीं है), और वे सूचियों की तुलना में तेज़ हैं। क्योंकि वे अपरिवर्तनीय हैं, हम उन्हें शब्दकोशों में कुंजी के रूप में भी उपयोग कर सकते हैं। टुपल्स का उपयोग तब भी किया जा सकता है जब हम किसी फ़ंक्शन से कई परिणाम वापस करना चाहते हैं। 
 
 

 हम संयोजन का उपयोग करके डेटा को टुपल में जोड़ सकते हैं। 
 
 

 81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।
 

 बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।
 
 टपल =(1, 2, 3) प्रिंट (ट्यूपल) # प्रिंट (1, 2, 3) टपल =टुपल + (4, 5, 6) प्रिंट (ट्यूपल) # प्रिंट (1, 2, 3, 4 , 5, 6)
 
शब्दकोश
 

 शब्दकोश डेटा संरचनाएं हैं जो जावास्क्रिप्ट में वस्तुओं की तरह प्रमुख मूल्य जोड़े रखती हैं। सूचियों की तरह, ये डेटा संरचनाएं परिवर्तनशील हैं, जिसका अर्थ है कि हम इसका डेटा बदल सकते हैं। 
 
 

 एक प्रमुख मूल्य जोड़ी का एक उदाहरण एक व्यक्ति की विशेषताएं और उन विशेषताओं का विवरण है। नाम, उम्र, ऊंचाई और वजन सभी कुंजी हो सकते हैं। जोश, 33, 5'10, 180 एलबीएस, सभी उन चाबियों के लिए मूल्य हो सकते हैं। 
 
 
 dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'}
 

 क्योंकि शब्दकोश परिवर्तनशील हैं, हम 'जोश' को दूसरे नाम में बदल सकते हैं। 
 
 
 dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} dict['name'] ='Patrick' प्रिंट (तानाशाही) # प्रिंट {'नाम':'पैट्रिक', 'आयु':33, 'ऊंचाई':"5'10", 'वजन':'180 पाउंड'}
 

 हम नए प्रमुख मूल्य जोड़े बनाकर मूल्य जोड़ सकते हैं। 
 
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs' } dict['location'] ='San Francisco' प्रिंट (तानाशाही) # प्रिंट {'नाम':'जोश', 'उम्र':33, 'ऊंचाई':"5'10", 'वजन':'180 पाउंड', 'स्थान':'सैन फ्रांसिस्को'} 

 हम डेल कीवर्ड, पॉप (), या पॉपिटेम () विधियों का उपयोग करके एक शब्दकोश में प्रमुख मूल्य जोड़े को भी हटा सकते हैं। ध्यान दें कि शब्दकोशों के साथ पॉप () को एक तर्क लेना चाहिए, इसलिए हमें शब्दकोश से अंतिम कुंजी मूल्य जोड़ी से हटाने के लिए पॉपिटेम () की आवश्यकता होती है। 
 
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} del dict['name']print(dict) # प्रिंट {'उम्र':33, 'ऊंचाई':"5'10", 'वजन':'180 पाउंड'}
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} dict.pop('name')print(dict. )# प्रिंट {'उम्र':33, 'ऊंचाई':"5'10", 'वजन':'180 पाउंड'}
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} dict.popitem()print(dict)# प्रिंट {'नाम':'जोश', 'उम्र':33, 'ऊंचाई':"5'10"}
 

 हम केवल कुंजी या केवल एक शब्दकोश के मूल्यों को प्रिंट कर सकते हैं। 
 
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs' } Print(dict.keys())# Prints dict_keys (['नाम', 'आयु', 'ऊंचाई', 'वजन'])
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} Print(dict.values())# Prints dict_values (['जोश', 33, "5'10", '180 एलबीएस'])
 

 कुंजी मूल्य जोड़े के रूप में मुद्रित करने के लिए, हम आइटम () विधि का उपयोग कर सकते हैं। 
 
 
dict ={'name':'Josh', 'age':33, 'height':"5'10", 'weight':'180 lbs'} Print(dict.items())# Prints dict_items ([('नाम', 'जोश'), ('उम्र', 33), ('ऊंचाई', "5'10"), ('वजन', '180 पाउंड')])
 
सेट
 

 सेट अद्वितीय तत्वों के परिवर्तनशील, अनियंत्रित संग्रह हैं, जिसका अर्थ है कि उनमें डुप्लिकेट तत्व शामिल नहीं हैं। सेट शब्दकोशों की तरह दिखते हैं जिसमें वे दोनों घुंघराले कोष्ठक में डेटा रखते हैं, लेकिन शब्दकोशों के विपरीत, सेट में कुंजी मूल्य जोड़े नहीं होते हैं। 
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} प्रिंट (सेट)# प्रिंट {1, 2, 3, 4}
 

 हम ऐड () विधि का उपयोग करके सेट में तत्वों को जोड़ सकते हैं। 
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} set.add(5)print(set)# प्रिंट {1, 2, 3, 4, 5}
 

 सेट, यूनियन (), इंटरसेक्शन (), डिफरेंशियल (), और सिमेट्रिक_डिफरेंस () का उपयोग करते समय हमारे लिए चार अन्य विधियाँ उपलब्ध हैं। 
 
 
 
यूनियन ():यूनियन () विधि दो अंतर सेटों को जोड़ती है, दोनों की समानताओं को लेकर और इसे बिना किसी डुप्लिकेट के एकल सेट के रूप में तैयार करती है।
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} सेट। जोड़ें (5) प्रिंट (सेट) # प्रिंट {1, 2, 3, 4, 5} दूसरा सेट ={3, 3, 4, 4, 5, 5, 6}प्रिंट(सेट.यूनियन(अन्यसेट))# प्रिंट {1, 2, 3, 4, 5, 6}
 
 
चौराहे ():प्रतिच्छेदन विधि दोनों सेटों में सामान्य तत्वों को ढूंढती है।
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} सेट। जोड़ें (5) प्रिंट (सेट) # प्रिंट {1, 2, 3, 4, 5} दूसरा सेट ={3, 3, 4, 4, 5, 5, 6}प्रिंट(set.intersection(anotherSet))# प्रिंट {3, 4, 5}
 
 
difference():डिफरेंशियल मेथड इंटरसेक्शन मेथड के विपरीत काम करता है जिसमें यह सभी समानताओं को निकालता है और पहले सेट से जो बचा है उसे प्रिंट करता है।
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} सेट। जोड़ें (5) प्रिंट (सेट) # प्रिंट {1, 2, 3, 4, 5} दूसरा सेट ={3, 3, 4, 4, 5, 5, 6}प्रिंट(सेट.डिफरेंस(अन्यसेट))# प्रिंट {1, 2}
 
 
सिमेट्रिक_डिफरेंस ():सिमेट्रिक_डिफरेंस () मेथड डिफरेंस मेथड के समान है, सिवाय इसके कि हमें आउटपुट में दोनों सेटों का अंतर मिलता है।
 
 
सेट ={1, 2, 2, 2, 3, 3, 4, 4} सेट। जोड़ें (5) प्रिंट (सेट) # प्रिंट {1, 2, 3, 4, 5} दूसरा सेट ={3, 3, 4, 4, 5, 5, 6}प्रिंट(सेट.सिमेट्रिक_डिफरेंस(अन्यसेट))# प्रिंट {1, 2, 6}