• Home
  • /
  • Blog
  • /
  • पायथन में 10 डेटा स्ट्रक्चर्स जो बच्चों को ज्ञात होनी चाहिए

पायथन में 10 डेटा स्ट्रक्चर्स जो बच्चों को ज्ञात होनी चाहिए

पायथन में डेटा स्ट्रक्चर्स

This post is also available in: English (English) العربية (Arabic)

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

डेटा स्ट्रक्चर क्या है?

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

कंप्यूटर विज्ञान और कंप्यूटर प्रोग्रामिंग में, डेटा स्ट्रक्चर को विभिन्न एल्गोरिदम के साथ उपयोग करने के उद्देश्य से डेटा को स्टोर करने के लिए चुना या डिज़ाइन किया जा सकता है।

पायथन में डेटा स्ट्रक्चर्स के प्रकार

पायथन दो प्रकार की डेटा स्ट्रक्चर्स प्रदान करता है:

  • अंतर्निहित डेटा स्ट्रक्चर्स
  • उपयोगकर्ता-परिभाषित (यूज़र-डिफाइंड) डेटा स्ट्रक्चर्स

Data Structures in PythonData Structures in Python

अंतर्निहित डेटा स्ट्रक्चर्स

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

पायथन में अंतर्निहित डेटा स्ट्रक्चर्स निम्नलिखित हैं:

  • लिस्ट (List)
  • डिक्शनरी (Dictionary)
  • टपल (Tuple)
  • सैट (Set)

1. लिस्ट

लिस्ट्स का उपयोग विभिन्न डेटा प्रकारों के डेटा को क्रमिक क्रम (सेक्वेंशिअल आर्डर) में संग्रहीत करने के लिए किया जाता है। लिस्ट के प्रत्येक तत्व को निर्दिष्ट एड्रेस हैं, जिन्हें एक अनुक्रमणिका (इंडेक्स) कहा जाता है। सूचकांक मान 0 से शुरू होता है और अंतिम तत्व तक चलता है। नकारात्मक अनुक्रमण की अनुमति है जो -1 से शुरू होती है जो आपको अंतिम से पहले तक के तत्वों तक पहुंचने में सक्षम बनाती है।

आइए लिस्ट्स में विभिन्न ऑपरेशन्स को समझते हैं:

एक लिस्ट बनाना

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

my_list = [] #create empty listprint(my_list)my_list = [1, 2, 3, ‘example’, 3.132] #creating list with dataprint(my_list)

आउटपुट:

[]

[1, 2, 3, ‘example’, 3.132]

लिस्ट में तत्व सम्मिलित करना

तत्वों को append(), extend() और insert() फंक्शन का उपयोग करके लिस्ट में डाला जा सकता है।

  • append() फ़ंक्शन इसमें पास किए गए सभी तत्वों को एक तत्व के रूप में जोड़ता है।
  • extend() फ़ंक्शन तत्वों को एक-एक करके सूची में जोड़ता है।
  • insert() फ़ंक्शन इंडेक्स मान में पारित तत्व को जोड़ता है और सूची के आकार को भी बढ़ाता है।

my_list = [1, 2, 3]print(my_list)my_list.append([555, 12]) #add as a single elementprint(my_list)my_list.extend([234, ‘more_example’]) #add as different elementsprint(my_list)my_list.insert(1, ‘insert_example’) #add element iprint(my_list)

आउटपुट:

[1, 2, 3]

[1, 2, 3, [555, 12]]

[1, 2, 3, [555, 12], 234, ‘more_example’]

[1, ‘insert_example’, 2, 3, [555, 12], 234, ‘more_example’]

लिस्ट से तत्व हटाना

कीवर्ड del, फ़ंक्शन pop() और remove() का उपयोग करके तत्वों को सूची से हटाया जा सकता है।

  • तत्वों को हटाने के लिए, del कीवर्ड का उपयोग करें जो कि पायथन में बनाया गया है लेकिन यह हमें कुछ भी वापस नहीं करता है।
  • यदि आप तत्व को वापस चाहते हैं, तो आप pop() फ़ंक्शन का उपयोग कर सकते हैं जो सूचकांक मान लेता है।
  • किसी तत्व को उसके मान से निकालने के लिए, आप remove() फ़ंक्शन का उपयोग कर सकते हैं।

my_list = [1, 2, 3, ‘example’, 3.132, 10, 30]del my_list[5] #delete element at index 5print(my_list)my_list.remove(‘example’) #remove element with valueprint(my_list)a = my_list.pop(1) #pop element from listprint(‘Popped Element: ‘, a, ‘ List remaining: ‘, my_list)my_list.clear() #empty the listprint(my_list)

आउटपुट:

[1, 2, 3, ‘example’, 3.132, 30]

[1, 2, 3, 3.132, 30]

Popped Element: 2 List remaining: 1, 3, 3.132, 30]

[]

लिस्ट के तत्वों तक पहुंचना

तत्वों तक पहुँचना पायथन में स्ट्रिंग्स (Strings) तक पहुँचने के समान है। आप अनुक्रमणिका मान पास कर सकते हैं और इसलिए आवश्यकतानुसार मान प्राप्त कर सकते हैं।

my_list = [1, 2, 3, ‘example’, 3.132, 10, 30]for element in my_list: #access elements one by one print(element)print(my_list) #access all elementsprint(my_list[3]) #access index 3 elementprint(my_list[0:2]) #access elements from 0 to 1 and exclude 2print(my_list[::-1]) #access elements in reverse

आउटपुट:

1

2

3

example

3.132

10

30

[1, 2, 3, ‘example’, 3.132, 10, 30]

example

[1. 2]

[30, 10, 3.132, ‘example’, 3, 2, 1]

अन्य फंक्शन्स

  • len() फ़ंक्शन हमें लिस्ट की लंबाई देता है।
  • index() फ़ंक्शन पास किए गए मान का इंडेक्स मान ढूंढता है जहां यह पहली बार सामने आया है।
  • count() फ़ंक्शन इसे पास किए गए मान की गिनती पाता है।
  • sorted() और sort() फ़ंक्शन दोनों लिस्ट के मानों को सॉर्ट करते हैं। sorted() में रिटर्न प्रकार होता है जबकि sort() मूल लिस्ट को संशोधित करता है।

my_list = [1, 2, 3, 10, 30, 10]print(len(my_list)) #find length of listprint(my_list.index(10)) #find index of element that occurs firstprint(my_list.count(10)) #find count of the elementprint(sorted(my_list)) #print sorted list but not change originalmy_list.sort(reverse=True) #sort original listprint(my_list)

आउटपुट:

6

3

2

[1, 2, 3, 10, 10, 30]

[30, 10, 10, 3, 2, 1]

2. डिक्शनरी

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

एक डिक्शनरी बनाना

डिक्शनरी को ब्रेसिज़ (कोष्ठक) का उपयोग करके या dict() फ़ंक्शन का उपयोग करके बनाया जा सकता है। जब भी आप डिक्शनरी के साथ काम करते हैं तो आपको कुंजी-मूल्य जोड़े जोड़ने की आवश्यकता होती है।

my_dict = {} #empty dictionaryprint(my_dict)my_dict = {1: ‘Python’, 2: ‘Java’} #dictionary with elementsprint(my_dict)

आउटपुट:

{}

{1: ‘Python’, 2: ‘Java’}

कुंजी बदलना और जोड़ना, मूल्य जोड़ना

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

my_dict = {‘First’: ‘Python’, ‘Second’: ‘Java’}print(my_dict)my_dict[‘Second’] = ‘C++’ #changing elementprint(my_dict)my_dict[‘Third’] = ‘Ruby’ #adding key-value pairprint(my_dict)

आउटपुट:

{‘First’: ‘Python’, ‘Second’: ‘Java’}

{‘First’: ‘Python’, ‘Second’: ‘C++’}

{‘First’: ‘Python’, ‘Second’: ‘C++’, ‘Third’: ‘Ruby’}

कुंजी, मान जोड़े को हटाना

फ़ंक्शन pop(), popitem() और clear() का उपयोग करके तत्वों को डिक्शनरी से हटाया जा सकता है।

  • मानों को हटाने के लिए, आप pop() फ़ंक्शन का उपयोग करते हैं जो हटाए गए मान को लौटाता है।
  • की-वैल्यू पेयर को पुनः प्राप्त करने के लिए, आप popitem() फ़ंक्शन का उपयोग करते हैं, जो एक कुंजी और मान टपल देता है।
  • संपूर्ण डिक्शनरी को साफ़ करने के लिए, आप clear() फ़ंक्शन का उपयोग करते हैं।

my_dict = {‘First’: ‘Python’, ‘Second’: ‘Java’, ‘Third’: ‘Ruby’}a = my_dict.pop(‘Third’) #pop elementprint(‘Value:’, a)print(‘Dictionary:’, my_dict)b = my_dict.popitem() #pop the key-value pairprint(‘Key, value pair:’, b)print(‘Dictionary’, my_dict)my_dict.clear() #empty dictionaryprint(‘n’, my_dict)

आउटपुट:

Value: Ruby

Dictionary: {‘First’: ‘Python’, ‘Second’: ‘Java’}

Key, value pair: (‘Second’, ‘Java’)

Dictionary {‘First’: ‘Python’}

{}

तत्वों तक पहुंचना

आप केवल कुंजियों का उपयोग करके तत्वों तक पहुँच सकते हैं। आप या तो get() फ़ंक्शन का उपयोग कर सकते हैं या केवल मुख्य मानों को पास कर सकते हैं और आप मानों को पुनः प्राप्त करने में सक्षम होंगे।

my_dict = {‘First’: ‘Python’, ‘Second’: ‘Java’}print(my_dict[‘First’]) #access elements using keysprint(my_dict.get(‘Second’))

आउटपुट:

पाइथन

जावा

अन्य फंक्शन्स

इन बुनियादी कार्यों के अलावा, विशिष्ट कार्यों को करने के लिए कुछ अन्य फंक्शन्स भी हैं। ये हैं:

  • keys(): यह कुंजी लौटाता है।
  • values(): इसका उपयोग मान वापस करने के लिए किया जाता है।
  • items(): यह की-वैल्यू पेयर लौटाता है।

my_dict = {‘First’: ‘Python’, ‘Second’: ‘Java’, ‘Third’: ‘Ruby’}print(my_dict.keys()) #get keysprint(my_dict.values()) #get valuesprint(my_dict.items()) #get key-value pairsprint(my_dict.get(‘First’))

आउटपुट:

dict_keys([‘First’, ‘Second’, ‘Third’])

dict_values([‘Python’, ‘Java’, ‘Ruby’])

dict_items([(‘First’, ‘Python’), (‘Second’, ‘Java’), (‘Third’, ‘Ruby’)])

पाइथन

3. टपल

टुपल्स लिस्ट के समान हैं सिवाय इसके कि एक बार टुपल में दर्ज किए गए डेटा को किसी भी परिस्थिति में बदला नहीं जा सकता है। एकमात्र अपवाद तब होता है जब टपल के अंदर का डेटा परिवर्तनशील होता है। निम्नलिखित उदाहरण आपको समझने में मदद करेगा।

एक टपल बनाना

आप कोष्ठक का उपयोग करके या tuple() फ़ंक्शन का उपयोग करके एक टपल बना सकते हैं।

my_tuple = (1, 2, 3) #create tuplet2 = tuple([1, 4, 6])print(my_tuple)print(t2)

आउटपुट:

(1, 2, 3)

(1, 4, 6)

तत्वों तक पहुंचना

तत्वों तक वैसे ही पहुंचा जा सकता हैं जैसे लिस्ट में मानों तक पहुंचा जाता है।

my_tuple2 = (1, 2, 3, ‘phyton’) #access elementsfor x in my_tuple2: print(x)print(my_tuple2)print(my_tuple2[0])print(my_tuple2[:])print(my_tuple2[3][4])

आउटपुट:

1

2

3

python

(1, 2, 3, ‘python’)

1

(1, 2, 3, ‘python’)

o

तत्वों को जोड़ना

मानों को जोड़ने के लिए, आप ‘+’ ऑपरेटर का उपयोग करते हैं जो इसे जोड़ने के लिए एक और टपल लेगा।

my_tuple = (1, 2, 3)my_tuple = my_tuple + (4, 5, 6) #add elementsprint(my_tuple)

आउटपुट:

(1, 2, 3, 4, 5, 6)

अन्य फंक्शन्स

इन बुनियादी कार्यों के अलावा, विशिष्ट कार्यों को करने के लिए कुछ अन्य फंक्शन्स भी हैं। निम्नलिखित उदाहरण इन फंक्शन्स की व्याख्या करता है।

my_tuple = (1, 2, 3, [‘hindi’, ‘python’])my_tuple[3][0] = ‘english’print(my_tuple)print(my_tuple.count(2))print(my_tuple.index([‘english’, ‘python’]))

आउटपुट:

(1, 2, 3, [‘english’], [‘python’])

1

3

4. सैट

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

एक सेट बनाना

कर्ली ब्रेसिज़ {} का उपयोग करके सेट बनाए जाते हैं लेकिन कुंजी-मूल्य जोड़े जोड़ने के बजाय, आप केवल मान पास करते हैं।

my_set = {1, 2, 3, 4, 5, 5, 5} #create setprint(my_set)

आउटपुट:

{1, 2, 3, 4, 5}

तत्वों को जोड़ना

तत्वों को जोड़ने के लिए, आप add() फ़ंक्शन का उपयोग करते हैं और इसे मान देते हैं।

my_set = {1, 2, 3}my_set.add(4) #add element to setprint(my_set)

आउटपुट:

{1, 2, 3, 4}

सेट में ऑपरेशन्स

  • uniion() फ़ंक्शन दोनों सेटों में मौजूद डेटा को जोड़ता है।
  • intersection() फ़ंक्शन दोनों सेटों में मौजूद सामान्य डेटा को ढूंढता है।
  • difference() फ़ंक्शन दोनों में मौजूद डेटा को हटा देता है और केवल पास किए गए सेट में मौजूद डेटा को आउटपुट करता है।
  • symmetric_difference() difference() फ़ंक्शन के समान है लेकिन डेटा को आउटपुट करता है जो दोनों सेटों में शेष है।

निम्नलिखित उदाहरण एक सेट में ऑपरेशन्स को समझाता है।

my_set = {1, 2, 3, 4}my_set_2 = {3, 4, 5, 6}print(my_set.union(my_set_2), ‘———-‘, my_set | my_set_2)print(my_set.intersection(my_set_2), ‘———-‘, my_set & my_set_2)print(my_set.difference(my_set_2), ‘———-‘, my_set – my_set_2)print(my_set.symmetric_difference(my_set_2), ‘———-‘, my_set ^ my_set_2)my_set.clear()print(my_set)

आउटपुट:

{1, 2, 3, 4, 5, 6} —————– {1, 2, 3, 4, 5, 6}

{3, 4} ————— {3, 4}

{1, 2} ————— {1, 2}

{1, 2, 5, 6} ————— {1, 2, 5, 6}

set()

उपयोगकर्ता-परिभाषित (यूज़र-डिफाइंड) डेटा स्ट्रक्चर्स

ये वे डेटा स्ट्रक्चर्स हैं जो पायथन द्वारा समर्थित नहीं हैं, लेकिन पायथन द्वारा समर्थित अवधारणाओं का उपयोग करके समान कार्यक्षमता को प्रतिबिंबित करने के लिए प्रोग्राम किया जा सकता है।

1. स्टैक

स्टैक लास्ट-इन-फर्स्ट-आउट (LIFO) के सिद्धांत पर आधारित लीनियर डेटा स्ट्रक्चर हैं, जहां अंतिम दर्ज किया गया डेटा सबसे पहले एक्सेस किया जाएगा। यह ऐरे संरचना का उपयोग करके बनाया गया है और इसके दो ऑपरेशन हैं। पुश (तत्व जोड़ना) तत्व और पॉप (तत्व हटाना) और शीर्ष के रूप में स्टैक कॉल में दो सिरों में से एक से तत्वों तक पहुंचना। यह TOP स्टैक की वर्तमान स्थिति का सूचक है। स्टैक का उपयोग रिकर्सिव प्रोग्रामिंग, रिवर्सिंग वर्ड्स, वर्ड एडिटर्स में पूर्ववत तंत्र, आदि जैसे अनुप्रयोगों में प्रमुखता से किया जाता है।

stack = [‘first’, ‘second’, ‘third’]print(stack)print()# pushing elementsstack.append(‘fourth’)stack.append(‘fifth’)print(stack)print()# printing topn = len(stack)print(stack[n-1])print()# poping elementstack.pop()print(stack)

आउटपुट:

[‘first’, ‘second’, ‘third’]

[‘first’, ‘second’, ‘third’, ‘fourth’, ‘fifth’]

fifth

[‘first’, ‘second’, ‘third’, ‘fourth’]

2. कियु

कियु एक लीनियर डेटा स्ट्रक्चर है जो एक छोर से तत्वों को सम्मिलित करने की अनुमति देती है (जिसे REAR कहा जाता है) और दूसरे से हटाना (जिसे FRONT कहा जाता है)। इस प्रकार यह फर्स्ट इन फर्स्ट आउट (FIFO) पद्धति का अनुसरण करता है।

queue = [‘first’, ‘second’, ‘third’]print(queue)print()# pushing elementsqueue.append(‘fourth’)queue.append(‘fifth’)print(queue)print()# printing headprint(queue[0])# printing tailn = len(queue)print(queue[n-1])print()# poping elementqueue.remove(queue[0])print(queue)

आउटपुट

[‘first’, ‘second’, ‘third’]

[‘first’, ‘second’, ‘third’, ‘fourth’, ‘fifth’]

first

fifth

[‘second’, ‘third’, ‘fourth’, ‘fifth’]

3. ट्री

ट्री एक नॉन-लीनियर लेकिन पदानुक्रमित डेटा स्ट्रक्चर है। सबसे ऊपरी तत्व को ट्री की रुट के रूप में जाना जाता है क्योंकि ऐसा माना जाता है कि यह रुट से शुरू होता है। ट्री के अंत में तत्वों को इसकी लीव्ज़ (एकवचन लीफ) के रूप में जाना जाता है। ट्री डेटा संग्रहीत करने के लिए उपयुक्त होते हैं जो एक दूसरे से रैखिक (लीनियर) रूप से जुड़े नहीं होते हैं लेकिन एक पदानुक्रम बनाते हैं।

class node:def __init__(self, ele):self.ele = eleself.left = Noneself.right = Nonedef preorder(self):if self:print(self.ele)preorder(self.left)preorder(self.right)n = node(‘first’)n.left = node(‘second’)n.right = node(‘third’)preorder(n)

आप यहां ट्री ट्रैवर्सल देख सकते हैं।

आउटपुट:

first

second

third

4. लिंक्ड लिस्ट

एक लिंक्ड लिस्ट एक लीनियर डेटा स्ट्रक्चर है, जिसमें तत्वों को सन्निहित स्मृति स्थानों पर संग्रहीत नहीं किया जाता है। लिंक्ड लिस्ट के तत्वों को पॉइंटर्स का उपयोग करके जोड़ा जाता है जैसा कि नीचे दी गई छवि में दिखाया गया है:

llist = [‘first’, ‘second’, ‘third’]print(llist)print()# adding elementsllist.append(‘fourth’)llist.append(‘fifth’)llist.insert(3, ‘sixth’)print(llist)print()llist.remove(‘second’)print(llist)print()

आउटपुट:

[‘first’, ‘second’, ‘third’]

[‘first’, ‘second’, ‘third’, ‘sixth’, ‘fourth’, ‘fifth’]

[‘first’, ‘third’, ‘sixth’, ‘fourth’, ‘fifth’]

5. ग्राफ़

ग्राफ एक गैर-रेखीय (नॉन-लीनियर) डेटा स्ट्रक्चर है जिसमें नोड्स और किनारों होते हैं। नोड्स को कभी-कभी कोने के रूप में भी जाना जाता है और किनारे रेखाएं या चाप होते हैं जो ग्राफ़ में किसी भी दो नोड्स को जोड़ते हैं। एक ग्राफ में शिखर (या नोड्स) और किनारों का एक सीमित सेट होता है जो नोड्स की एक जोड़ी को जोड़ता है।

class adjnode:def __init__(self, val):self.val = valself.next = Noneclass graph:def __init__(self, vertices):self.v = verticesself.ele = [None]*self.vdef edge(self, src, dest):node = adjnode(dest)node.next = self.ele[src]self.ele[src] = nodenode = adjnode(src)node.next = self.ele[dest]self.ele[dest] = nodedef __repr__(self):for i in range(self.v):print(“Adjacency list of vertex {}n head”.format(i), end=””)temp = self.ele[i]while temp:print(” -> {}”.format(temp.val), end=””)temp = temp.nextg = graph(4)g.edge(0, 2)g.edge(1, 3)g.edge(3, 2)g.edge(0, 3)g.__repr__()

आउटपुट:

शीर्ष 0 की अडजैसेन्सी लिस्ट

head -> 3 -> 2

शीर्ष 1 की अडजैसेन्सी लिस्ट

head -> 3

शीर्ष 2 की अडजैसेन्सी लिस्ट

head -> 3 -> 0

शीर्ष 3 की अडजैसेन्सी लिस्ट

head -> 0 -> 2 -> 1

6. हैश मैप

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

def printdict(d):for key in d:print(key, “->”, d[key])hm = {0: ‘first’, 1: ‘second’, 2: ‘third’}printdict(hm)print()hm[3] = ‘fourth’printdict(hm)print()hm.popitem()printdict(hm)

आउटपुट:

0 -> first

1 -> second

2 -> third

0 -> first

1 -> second

2 -> third

3 -> fourth

0 -> first

1 -> second

2 -> third

{"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}
>