पायथन में अपरिवर्तनीय डेटा संरचनाओं को कैसे कार्यान्वित करें?

समस्या

आपको पायथन में अपरिवर्तनीय डेटा संरचनाओं को लागू करने की आवश्यकता है।

परिचय..

जब आप एक ही समय में समानांतर प्रोग्रामिंग में डेटा के एक टुकड़े को संशोधित करने वाले कई लोगों को रोकना चाहते हैं तो अपरिवर्तनीय डेटा संरचनाएं बहुत आसान होती हैं। परिवर्तनशील डेटा संरचनाएं (जैसे ऐरे) को किसी भी समय बदला जा सकता है जबकि अपरिवर्तनीय डेटा संरचनाएं नहीं हो सकतीं।

इसे कैसे करें..

मैं आपको चरण दर चरण दिखाता हूं कि अपरिवर्तनीय और परिवर्तनशील डेटा संरचनाओं से कैसे निपटें।

उदाहरण

# STEP 01 - एक म्यूटेबल ऐरे बनाएं।# एक arrayatp_players परिभाषित करें =['मरे', 'नडाल', 'जोकोविच']प्रिंट (f" *** मेरे एरे में मूल डेटा है - {atp_players}") 

 *** मेरी सरणी में मूल डेटा है -
 
['मरे', 'नडाल', 'जोकोविच']
 

 
 
 
# खिलाड़ी का नाम मरे से बदलकर Federeratp_players[0] ='Federer'print(f" *** मेरी सरणी में संशोधित डेटा है - {atp_players}")
 

 *** मेरी सरणी में संशोधित डेटा है -
 
['फेडरर', 'नडाल', 'जोकोविच']
 

 निष्कर्ष  
 

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

 दूसरी ओर टुपल्स थोड़ा अलग व्यवहार करते हैं, नीचे दिए गए उदाहरण पर एक नज़र डालें।
 
# STEP 02 - Tupletry को बदलने का प्रयास करें:atp_players_tuple =('Murray', 'Nadal', 'Djokovic')print(f" *** मेरे टपल में मूल डेटा है - {atp_players_tuple}")atp_players_tuple[0] ='फेडरर' अपवाद को त्रुटि के रूप में छोड़कर:प्रिंट (f" *** डेटा को संशोधित करने का प्रयास किया लेकिन - {त्रुटि}")
 के साथ समाप्त हुआ 

 
 
 
*** मेरे टपल में मूल डेटा है - ('मरे', 'नडाल', 'जोकोविच')*** डेटा को संशोधित करने का प्रयास किया लेकिन अंत में - 'टुपल' ऑब्जेक्ट आइटम असाइनमेंट का समर्थन नहीं करता है
 

 निष्कर्ष: 
 

 आपने ऊपर जो देखा है, वह है, टपल को संशोधित नहीं किया जा सकता है? हालांकि, एक अपवाद है, अगर टुपल में सरणियाँ हैं तो मानों को बदला जा सकता है।
 
atp_players_array_in_tuple =(['मरे'], ['नडाल'], ['जोकोविच'])प्रिंट(f" *** सरणियों के साथ मेरे टपल में मूल डेटा है - {atp_players_array_in_tuple}")atp_players_array_in_tuple[0][ 0] ='Federer'print(f" *** सरणियों के साथ मेरे टपल में संशोधित डेटा है - {atp_players_array_in_tuple}")
 

 
 
 
*** सरणियों के साथ मेरे टपल में मूल डेटा है - (['मरे'], ['नडाल'], ['जोकोविच'])*** सरणियों के साथ मेरे टपल में संशोधित डेटा है - (['फेडरर '], ['नडाल'], ['जोकोविच'])
 

 तो डेटा की सुरक्षा कैसे करें? हम्म, केवल सरणियों को टुपल्स में परिवर्तित करके।
 <पूर्व>कोशिश करें:atp_players_tuple_in_tuple =(('मरे'), ('नडाल'), ('जोकोविच')) प्रिंट (f" *** मेरे टपल में मूल डेटा है - {atp_players_tuple_in_tuple}")atp_players_tuple_in_tuple[0] ='फेडरर' अपवाद को त्रुटि के रूप में छोड़कर:प्रिंट (f" *** मेरे टुपल में डेटा को संशोधित करने का प्रयास किया लेकिन - {त्रुटि}")

*** मेरे टपल में मूल डेटा है - ('मरे', 'नडाल', 'जोकोविच')*** मेरे टपल में डेटा को संशोधित करने का प्रयास किया लेकिन अंत में - 'टुपल' ऑब्जेक्ट आइटम असाइनमेंट का समर्थन नहीं करता है 

 और भी बहुत कुछ है .. पायथन में NamedTuple नामक एक अद्भुत उपकरण है। यह एक वर्ग है जिसे आप एक कंस्ट्रक्टर बनाने के लिए बढ़ा सकते हैं। आइए प्रोग्राम के रूप में समझते हैं।
 
# ग्रैंडस्लैम टाइटल्स पर पाइथॉन्स वे में एक साधारण क्लास बनाएं। क्लास ग्रैंडस्लैम्सपायथनवे:def __init__ (सेल्फ, प्लेयर, टाइटल्स):सेल्फ.प्लेयर =प्लेयरसेल्फ.टाइटल्स =टाइटलस्टैट्स =ग्रैंडस्लैम्सपायथनवे ("फेडरर", 20) प्रिंट (एफ" *** आँकड़ों का विवरण {stats.player} - {stats.titles}")
 . के रूप में होता है 

 
 
 
*** Stats में फेडरर के रूप में विवरण हैं - 20
 

 आप इस वर्ग के बारे में क्या सोचते हैं, क्या यह अपरिवर्तनीय है? आइए हम फेडरर को नडाल में बदलकर इसे देखें।
 
stats.player ='Nadal'print(f" *** Stats का विवरण {stats.player} - {stats.titles}")
 के रूप में होता है 

 
 
 
*** Stats का विवरण नडाल - 20 के रूप में है
 

 इसलिए कोई आश्चर्य नहीं कि यह एक अपरिवर्तनीय डेटा संरचना है क्योंकि हम फेडरर को नडाल में अपडेट करने में सक्षम हैं। अब हम NamedTuple के साथ एक क्लास बनाते हैं और देखते हैं कि यह डिफ़ॉल्ट व्यवहार क्या है।
 
टाइप करने से इंपोर्ट NamedTupleclass GrandSlamsWithNamedTuple(NamedTuple):खिलाड़ी:strtitles:intstats =GrandSlamsWithNamedTuple("Federer", 20)print(f" *** Stats में {stats.player} - {stats.title}") के विवरण होते हैं। stats.player ='Djokovic'print(f" *** Stats का विवरण {stats.player} - {stats.titles}")
 के रूप में होता है 

 
 
 
*** Stats में फेडरर के रूप में विवरण हैं - 20
 

 
 
 <पूर्व>-------------------------------------------------------- ---------------------------- एट्रिब्यूट एरर ट्रेसबैक (सबसे हालिया कॉल लास्ट) इन 10 प्रिंट (f" *** आँकड़ों का विवरण {आँकड़े के रूप में है .player} - {stats.titles}")11--->12 stats.player ='जोकोविच'13 प्रिंट(f" *** Stats का विवरण {stats.player} - {stats.titles}")AttributeError के रूप में है :विशेषता सेट नहीं कर सकता

ऐसा लगता है कि जोकोविच को 20 ग्रैंडस्लैम खिताब तक पहुंचने के लिए कुछ और इंतजार करना पड़ा।

हालांकि हम _replace के दौरान कॉपी बनाने और मानों को अपडेट करने के लिए _replace विधि का उपयोग कर सकते हैं।

djokovic_stats =stats._replace(player="Djokovic", title=17)print(f" *** djokovic_stats का विवरण {djokovic_stats.player} - {djokovic_stats.titles}")

*** djokovic_stats का विवरण जोकोविच के रूप में है - 17

उदाहरण

अंत में मैं एक उदाहरण रखूंगा जिसमें ऊपर बताई गई हर चीज शामिल है।

इस उदाहरण के लिए, मान लीजिए कि हम सब्जी की दुकान के लिए सॉफ्टवेयर लिख रहे हैं।

टाइप करने से आयात Tuple# एक खरीद वर्ग का प्रतिनिधित्व करने के लिए एक वर्ग बनाएं मूल्य(NamedTuple):id:intname:strprice:int # मूल्य डॉलर में# खरीद वर्ग को ट्रैक करने के लिए एक वर्ग बनाएं खरीद(NamedTuple):purchase_id:intitems:Tuple[ Prices]# सब्जियों की वस्तुएं और उनके अनुरूप मूल्य बनाएं गाजर =कीमतें (1, "गाजर", 2) टमाटर =कीमतें (2, "टमाटर", 3) बैंगन =कीमतें (3, "बैंगन", 5)# अब मान लें कि हमारा पहले ग्राहक मिस्टर टॉम ने गाजर खरीदी थी और टोमैटोटॉम_ऑर्डर =खरीद (1, (गाजर, टमाटर))# श्री टॉमटोटल_कॉस्ट =राशि (आइटम। टॉम_ऑर्डर.आइटम में आइटम के लिए मूल्य) प्रिंट (एफ) *** श्री टॉम से कुल लागत है - {total_cost}$")

आउटपुट

*** Mr.Tom की कुल लागत है - 5$