समस्या
आपको पायथन में अपरिवर्तनीय डेटा संरचनाओं को लागू करने की आवश्यकता है।
परिचय..
अपरिवर्तनीय डेटा संरचनाएं बहुत आसान होती हैं जब आप समानांतर प्रोग्रामिंग में एक ही समय में कई लोगों को डेटा के एक टुकड़े को संशोधित करने से रोकना चाहते हैं। परिवर्तनीय डेटा संरचनाएं (जैसे सरणी) किसी भी समय बदली जा सकती हैं जबकि अपरिवर्तनीय डेटा संरचनाएं नहीं बदली जा सकतीं।
इसे कैसे करें..
आइए मैं आपको चरण दर चरण दिखाता हूं कि अपरिवर्तनीय और परिवर्तनीय डेटा संरचनाओं से कैसे निपटें।
उदाहरण
# चरण 01 - एक परिवर्तनीय सरणी बनाएं। # एक सरणी परिभाषित करें
atp_players = ['Murray', 'Nadal', 'Djokovic']
print(f" *** मेरी सरणी में मूल डेटा है - {atp_players}")
*** मेरी सरणी में मूल डेटा है -
['Murray', 'Nadal', 'Djokovic']
# मरे से फेडरर में खिलाड़ी का नाम बदलना
atp_players[0] = 'Federer'
print(f" *** मेरी सरणी में संशोधित डेटा है - {atp_players}")
*** मेरी सरणी में संशोधित डेटा है -
['Federer', 'Nadal', 'Djokovic']
निष्कर्ष
हम सरणी मान को ऐसे ही बदलने में सक्षम हुए हैं जो उपयोगी हो सकता है यदि आप इस सरणी के अनन्य उपयोगकर्ता हैं। हालांकि, वास्तविक समय उत्पादन में कई प्रोग्राम इस सरणी का उपयोग परिवर्तनों के लिए कर सकते हैं और अप्रत्याशित डेटा का परिणाम हो सकता है।
दूसरी ओर टपल्स थोड़ा अलग व्यवहार करते हैं, नीचे दिए गए उदाहरण को देखें।
# चरण 02 - एक टपल बदलने का प्रयास करें
try:
atp_players_tuple = ('Murray', 'Nadal', 'Djokovic')
print(f" *** मेरे टपल में मूल डेटा है - {atp_players_tuple}")
atp_players_tuple[0] = 'Federer'
except Exception as error:
print(f" *** डेटा संशोधित करने का प्रयास किया लेकिन समाप्त हुआ - {error}")
*** मेरे टपल में मूल डेटा है - ('Murray', 'Nadal', 'Djokovic') *** डेटा संशोधित करने का प्रयास किया लेकिन समाप्त हुआ - 'tuple' object does not support item assignment
निष्कर्ष :
आपने ऊपर देखा है, टपल को संशोधित नहीं किया जा सकता है? हालांकि एक अपवाद है, यदि टपल के भीतर सरणियाँ हैं तो मान बदले जा सकते हैं।
atp_players_array_in_tuple = (['Murray'], ['Nadal'], ['Djokovic'])
print(f" *** सरणियों के साथ मेरे टपल में मूल डेटा है - {atp_players_array_in_tuple}")
atp_players_array_in_tuple[0][0] = 'Federer'
print(f" *** सरणियों के साथ मेरे टपल में संशोधित डेटा है - {atp_players_array_in_tuple}")
*** सरणियों के साथ मेरे टपल में मूल डेटा है - (['Murray'], ['Nadal'], ['Djokovic']) *** सरणियों के साथ मेरे टपल में संशोधित डेटा है - (['Federer'], ['Nadal'], ['Djokovic'])
तो डेटा की रक्षा कैसे करें? हम्म, बस सरणियों को टपल्स में परिवर्तित करके।
try:
atp_players_tuple_in_tuple = (('Murray'), ('Nadal'), ('Djokovic'))
print(f" *** मेरे टपल में मूल डेटा है - {atp_players_tuple_in_tuple}")
atp_players_tuple_in_tuple[0] = 'Federer'
except Exception as error:
print(f" *** मेरे टपल में डेटा संशोधित करने का प्रयास किया लेकिन समाप्त हुआ - {error}")
*** मेरे टपल में मूल डेटा है - ('Murray', 'Nadal', 'Djokovic') *** मेरे टपल में डेटा संशोधित करने का प्रयास किया लेकिन समाप्त हुआ - 'tuple' object does not support item assignment
इससे भी अधिक है.. पायथन में एक अद्भुत बिल्ट-इन टूल है जिसे NamedTuple कहा जाता है। यह एक क्लास है जिसे आप कंस्ट्रक्टर बनाने के लिए विस्तारित कर सकते हैं। आइए प्रोग्रामेटिक रूप से समझें।
# पायथन के तरीके से ग्रैंड स्लैम खिताब पर एक साधारण क्लास बनाएं।
class GrandSlamsPythonWay:
def __init__(self, player, titles):
self.player = player
self.titles = titles
stats = GrandSlamsPythonWay("Federer", 20)
print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
*** स्टैट्स में विवरण हैं Federer - 20
आपको क्या लगता है यह क्लास, क्या यह अपरिवर्तनीय है? आइए फेडरर को नडाल में बदलकर जांचते हैं।
stats.player = 'Nadal'
print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
*** स्टैट्स में विवरण हैं Nadal - 20
तो कोई आश्चर्य नहीं यह एक अपरिवर्तनीय डेटा संरचना है क्योंकि हम फेडरर को नडाल में अपडेट करने में सक्षम हैं। अब आइए NamedTuple के साथ एक क्लास बनाएं और देखें कि इसका डिफ़ॉल्ट व्यवहार क्या है।
from typing import NamedTuple
class GrandSlamsWithNamedTuple(NamedTuple):
player: str
titles: int
stats = GrandSlamsWithNamedTuple("Federer", 20)
print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
stats.player = 'Djokovic'
print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
*** स्टैट्स में विवरण हैं Federer - 20
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in
10 print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
11 ----> 12 stats.player = 'Djokovic'
13 print(f" *** स्टैट्स में विवरण हैं {stats.player} - {stats.titles}")
AttributeError: can't set attribute
लगता है जोकोविच को 20 ग्रैंड स्लैम खिताब तक पहुंचने के लिए कुछ और समय इंतजार करना पड़ेगा।
हालांकि हम _replace विधि का उपयोग करके एक प्रति बना सकते हैं और _replace के दौरान मान अपडेट कर सकते हैं।
djokovic_stats = stats._replace(player="Djokovic", titles=17)
print(f" *** djokovic_stats में विवरण हैं {djokovic_stats.player} - {djokovic_stats.titles}")
*** djokovic_stats में विवरण हैं Djokovic - 17
उदाहरण
अंत में मैं एक उदाहरण दूंगा जिसमें ऊपर बताई गई सभी चीजें शामिल हैं।
इस उदाहरण के लिए, मान लें कि हम सब्जी की दुकान के लिए सॉफ्टवेयर लिख रहे हैं।
from typing import Tuple
# एक खरीद को दर्शाने के लिए एक क्लास बनाएं
class Prices(NamedTuple):
id: int
name: str
price: int # डॉलर में कीमत
# खरीद को ट्रैक करने के लिए एक क्लास बनाएं
class Purchase(NamedTuple):
purchase_id: int
items: Tuple[Prices]
# सब्जी आइटम और उनकी संबंधित कीमतें बनाएं
carrot = Prices(1, "carrot", 2)
tomato = Prices(2, "tomato", 3)
eggplant = Prices(3, "eggplant", 5)
# अब मान लें कि हमारे पहले ग्राहक मिस्टर टॉम ने गाजर और टमाटर खरीदे
tom_order = Purchase(1, (carrot, tomato))
# मिस्टर टॉम से वसूलने के लिए कुल लागत जानने के लिए
total_cost = sum(item.price for item in tom_order.items)
print(f"*** मिस्टर टॉम से कुल लागत है - {total_cost}$")
आउटपुट
*** मिस्टर टॉम से कुल लागत है - 5$
