इस लेख में, आप उदाहरणों की मदद से उथली प्रतिलिपि और पायथन में गहरी प्रतिलिपि के बारे में जानेंगे।
पायथन में एक ऑब्जेक्ट की प्रतिलिपि बनाएँ
पाइथन में, हम =ऑब्जेक्ट की एक प्रति बनाने के लिए ऑपरेटर का उपयोग करते हैं । आप सोच सकते हैं कि यह एक नई वस्तु बनाता है; यह नहीं है। यह केवल एक नया चर बनाता है जो मूल वस्तु के संदर्भ को साझा करता है।
आइए एक उदाहरण लेते हैं जहां हम एक पुरानी_सूची नाम सूची बनाते हैं और =ऑपरेटर का उपयोग करके नए_सूची में ऑब्जेक्ट संदर्भ पास करते हैं ।
उदाहरण 1: = ऑपरेटर का उपयोग करके कॉपी करें
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
जब हम प्रोग्राम के ऊपर चलेंगे, तो आउटपुट होगा:
पुरानी सूची: (1, 2, 3), (4, 5, 6), (7, 8, 9)) पुरानी सूची की आईडी: 140673303268168 नई सूची: ((1, 2, 3), (4, 5) , 6), (7, 8, 9)) नई सूची की आईडी: 140673303268168
जैसा कि आप आउटपुट से देख सकते हैं कि दोनों चर पुराने_सूची और नए_सूची समान आईडी हैं 140673303268168।
इसलिए, यदि आप new_list या old_list में किसी भी मान को संशोधित करना चाहते हैं, तो परिवर्तन दोनों में दिखाई देता है।
अनिवार्य रूप से, कभी-कभी आप मूल मूल्यों को अपरिवर्तित रखना चाहते हैं और केवल नए मूल्यों को संशोधित कर सकते हैं या इसके विपरीत। पायथन में, प्रतियां बनाने के दो तरीके हैं:
- उथली प्रतिलिपि
- गहरी प्रति
इन प्रतिलिपि को बनाने के लिए, हम copyमॉड्यूल का उपयोग करते हैं ।
मॉड्यूल की प्रतिलिपि बनाएँ
हम copyउथले और गहरी प्रतिलिपि के संचालन के लिए पायथन के मॉड्यूल का उपयोग करते हैं । मान लीजिए, आपको कंपाउंड लिस्ट को x कहने की जरूरत है। उदाहरण के लिए:
आयात प्रतिलिपि copy.copy (x) copy.deepcopy (x)
यहां, copy()x की उथली प्रति लौटाएं। इसी तरह, deepcopy()x की गहरी प्रति लौटाएं।
उथली प्रतिलिपि
उथली प्रतिलिपि एक नई वस्तु बनाती है जो मूल तत्वों के संदर्भ को संग्रहीत करती है।
इसलिए, एक उथली प्रतिलिपि नेस्टेड ऑब्जेक्ट्स की प्रतिलिपि नहीं बनाती है, इसके बजाय यह केवल नेस्टेड ऑब्जेक्ट्स के संदर्भ की प्रतिलिपि बनाती है। इसका मतलब है, एक प्रतिलिपि प्रक्रिया स्वयं नेस्टेड ऑब्जेक्ट्स की प्रतियों की पुनरावृत्ति या निर्माण नहीं करती है।
उदाहरण 2: उथली प्रति का उपयोग करके एक प्रति बनाएँ
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
पुरानी सूची: (1, 2, 3), (4, 5, 6), (7, 8, 9)) नई सूची: ((1, 2, 3), (4, 5, 6), (7) , 8, 9))
उपरोक्त कार्यक्रम में, हमने एक नेस्टेड सूची बनाई और फिर copy()विधि का उपयोग करके उथले की प्रतिलिपि बनाएँ ।
इसका मतलब यह समान सामग्री के साथ नई और स्वतंत्र वस्तु का निर्माण करेगा। इसे सत्यापित करने के लिए, हम old_list और new_list दोनों को प्रिंट करते हैं।
यह पुष्टि करने के लिए कि new_list old_list से अलग है, हम मूल में नई नेस्टेड ऑब्जेक्ट को जोड़ने और इसे जाँचने का प्रयास करते हैं।
उदाहरण 3: उथले कॉपी का उपयोग करके old_list में (4, 4, 4) जोड़ना
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
जब हम प्रोग्राम चलाते हैं, तो यह आउटपुट होगा:
पुरानी सूची: (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4) नई सूची: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
उपरोक्त कार्यक्रम में, हमने पुराने_सूची की उथली प्रति बनाई। New_list में old_list में संग्रहीत मूल नेस्टेड ऑब्जेक्ट्स के संदर्भ शामिल हैं। फिर हम नई सूची (4, 4, 4)को पुराने_सूची में जोड़ते हैं। इस नई सबलिस्ट को new_list में कॉपी नहीं किया गया था।
हालाँकि, जब आप किसी भी नेस्टेड ऑब्जेक्ट को पुराने_सूची में बदलते हैं, तो नए_लिस्ट में परिवर्तन दिखाई देते हैं।
उदाहरण 4: शॉलो कॉपी का उपयोग करके नई नेस्टेड ऑब्जेक्ट को जोड़ना
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
जब हम प्रोग्राम चलाते हैं, तो यह आउटपुट होगा:
पुरानी सूची: (1, 1, 1), (2, 'एए', 2), (3, 3, 3)) नई सूची: ((1, 1, 1), (2, 'एए', 2) ), (3, 3, 3)
उपरोक्त कार्यक्रम में, हमने पुराने_लिस्ट में परिवर्तन किए हैं old_list(1)(1) = 'AA'। अनुक्रमणिका पर old_list और new_list के दोनों उपसूची (1)(1)संशोधित किए गए थे। ऐसा इसलिए है, क्योंकि दोनों सूचियाँ समान नेस्टेड वस्तुओं के संदर्भ को साझा करती हैं।
गहरी प्रति
एक गहरी प्रतिलिपि एक नई वस्तु बनाती है और मूल तत्वों में मौजूद नेस्टेड वस्तुओं की प्रतियों को पुन: जोड़ती है।
उदाहरण 2 के साथ जारी रखें। हालांकि, हम मॉड्यूल deepcopy()में मौजूद फ़ंक्शन का उपयोग करके गहरी प्रतिलिपि बनाने जा रहे हैं copy। गहरी प्रतिलिपि मूल वस्तु और उसकी सभी नेस्टेड वस्तुओं की स्वतंत्र प्रतिलिपि बनाती है।
उदाहरण 5: डीकोपी () का उपयोग करके एक सूची की प्रतिलिपि बनाना
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
जब हम प्रोग्राम चलाते हैं, तो यह आउटपुट होगा:
पुरानी सूची: (1, 1, 1), (2, 2, 2), (3, 3, 3)) नई सूची: ((1, 1, 1), (2, 2, 2), (3) , 3, 3))
उपरोक्त कार्यक्रम में, हम deepcopy()प्रतिलिपि बनाने के लिए फ़ंक्शन का उपयोग करते हैं जो समान दिखता है।
हालाँकि, यदि आप मूल ऑब्जेक्ट old_list में किसी भी नेस्टेड ऑब्जेक्ट में परिवर्तन करते हैं, तो आपको कॉपी new_list में कोई परिवर्तन दिखाई नहीं देगा।
उदाहरण 6: दीप प्रतिलिपि का उपयोग करके सूची में एक नया नेस्टेड ऑब्जेक्ट जोड़ना
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
जब हम प्रोग्राम चलाते हैं, तो यह आउटपुट होगा:
पुरानी सूची: (1, 1, 1), ('बीबी', 2, 2), (3, 3, 3)) नई सूची: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
उपरोक्त कार्यक्रम में, जब हम old_list को एक नया मान देते हैं, तो हम देख सकते हैं कि केवल old_list संशोधित है। इसका अर्थ है, पुराने_सूची और नए_सूची दोनों स्वतंत्र हैं। ऐसा इसलिए है क्योंकि पुराने_सूची को पुन: कॉपी किया गया था, जो उसके सभी नेस्टेड ऑब्जेक्ट के लिए सही है।
