कॉपी - पायथन में उथला और गहरी प्रतिलिपि संचालन

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

>>> L1 = [1,2,3]
>>> L2 = L1
>>> id(L1), id(L2)
(2165544063496, 2165544063496)

उपरोक्त कोड के परिणाम से पता चलता है कि दोनों सूची वस्तुओं के लिए id() समान है, जिसका अर्थ है कि दोनों एक ही वस्तु को संदर्भित करते हैं। L2 को L1 की उथली प्रति कहा जाता है। चूंकि दोनों एक ही वस्तु को संदर्भित करते हैं, दोनों में से कोई भी परिवर्तन अन्य वस्तु में प्रतिबिंबित होगा।

>>> L1 = [1,2,3]
>>> L2 = L1
>>> L2[1] = 100
>>> L1,L2
([1, 100, 3], [1, 100, 3])

ऊपर के उदाहरण में, इंडेक्स नंबर पर आइटम। L2 का 1 बदल गया है। हम इस परिवर्तन को दोनों में प्रकट होते हुए देखते हैं।

जब कॉपी ऑपरेशन के साथ एक पूरी तरह से नई वस्तु बनाई जाती है, जिसमें नेस्टेड वस्तुओं की प्रतियां भी पुनरावर्ती रूप से जोड़ी जाती हैं, तो कॉपी को डीप कॉपी कहा जाता है।

पायथन मानक पुस्तकालय का कॉपी मॉड्यूल दो तरीके प्रदान करता है:

• copy.copy() - एक उथली कॉपी बनाता है
• copy.deepcopy() – एक डीप कॉपी बनाता है

एक उथली प्रतिलिपि एक नई वस्तु बनाती है और मूल तत्वों के संदर्भ को संग्रहीत करती है लेकिन नेस्टेड वस्तुओं की एक प्रति नहीं बनाती है। यह सिर्फ नेस्टेड वस्तुओं के संदर्भ की प्रतिलिपि बनाता है। परिणामस्वरूप, प्रतिलिपि प्रक्रिया पुनरावर्ती नहीं है।

>>> import copy
>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.copy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2.append([10,10,10])
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6], [10, 10, 10]])

यहाँ L1 एक नेस्टेड सूची है और L2 इसकी उथली प्रति है। हालांकि मूल सूची ऑब्जेक्ट का संदर्भ L2 में कॉपी किया गया है, इसके नेस्टेड तत्वों की प्रतिलिपि नहीं बनाई गई है। इसलिए, जब हम L2 में दूसरी सूची जोड़ते हैं, तो यह L1 में नहीं दिखाई देती है

हालाँकि, यदि हम चाइल्ड एलिमेंट में किसी एलीमेंट को संशोधित करने का प्रयास करते हैं, तो इसका प्रभाव दोनों सूचियों में दिखाई देगा

>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.copy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2[1][0] = 100
>>> L1,L2
([[1, 2, 3], [100, 5, 6]], [[1, 2, 3], [100, 5, 6]])

एक गहरी प्रतिलिपि हालांकि, एक नई वस्तु बनाती है और मूल तत्वों में मौजूद नेस्टेड वस्तुओं की प्रतियों को भी पुनरावर्ती रूप से जोड़ती है।

निम्नलिखित उदाहरण में, L2 L2 की एक गहरी प्रति है। अब अगर हम आंतरिक सूची के किसी भी तत्व को बदलते हैं, तो यह अन्य सूची में नहीं दिखाई देगा।

>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.deepcopy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2[1][0] = 100
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [100, 5, 6]])

इस प्रकार डीप कॉपी का प्रभाव आउटपुट द्वारा सत्यापित किया जाता है।