पायथन: उथले और गहरी प्रति रचनाकारों का कार्यान्वयन

Question

पॉइंटर्स की अवधारणा के बाद से सी ++ में कॉपी कन्स्ट्रक्टर (या अधिभारित असाइनमेंट ऑपरेटर) को कार्यान्वित करने में आसान स्थितियों में से अधिकांश स्थितियों में से अधिकांश है। हालांकि, मैं पाइथन में उथले और गहरी प्रति को कार्यान्वित करने के तरीके के बारे में काफी उलझन में हूं।

मुझे पता है कि पुस्तकालयों में से एक में विशेष आदेश हैं लेकिन वे आपके द्वारा लिखे गए वर्गों पर काम नहीं करते हैं। तो कार्यान्वित करने के सामान्य तरीके क्या हैं?

पीएस कुछ बुनियादी डेटा संरचनाओं (लिंक की गई सूची या पेड़) पर प्रक्रिया को दिखाया जाएगा।

संपादित करें: धन्यवाद, उन्होंने काम किया, यह वाक्यविन्यास में मेरी गलती थी। मुझे __copy__() और __deep_copy()__ के साथ इन कार्यों को ओवरराइट करने में बहुत दिलचस्पी है। उदाहरण के लिए। डेटा संरचना में किस प्रकार की जानकारी है, यह जानने के बिना मैं एक गहरी प्रति कैसे बना सकता हूं?

Answer 1

पायथन copy module कक्षाओं को कॉपी व्यवहार को अनुकूलित करने के लिए pickle module इंटरफ़ेस का पुन: उपयोग कर सकता है।

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

अन्यथा, आप आंतरिक स्थिति लौटने के लिए __getstate__() विधि निर्दिष्ट करते हैं। यह कोई संरचना हो सकती है कि आपकी कक्षा __setstate__() फिर से स्वीकार कर सके।

आप और/या को केवल प्रतिलिपि व्यवहार को नियंत्रित करने के तरीकों को भी निर्दिष्ट कर सकते हैं। इन तरीकों से सभी प्रतिलिपि बनाने की उम्मीद है, __deepcopy__() विधि को deepcopy() कॉलों को रिकर्सिव करने के लिए एक मेमो मैपिंग पास की जाती है।

एक उदाहरण हो सकता है:

from copy import deepcopy 

class Foo(object): 
    def __init__(self, bar): 
     self.bar = bar 
     self.spam = expression + that * generates - ham # calculated 

    def __copy__(self): 
     # self.spam is to be ignored, it is calculated anew for the copy 
     # create a new copy of ourselves *reusing* self.bar 
     return type(self)(self.bar) 

    def __deepcopy__(self, memo): 
     # self.spam is to be ignored, it is calculated anew for the copy 
     # create a new copy of ourselves with a deep copy of self.bar 
     # pass on the memo mapping to recursive calls to copy.deepcopy 
     return type(self)(deepcopy(self.bar, memo)) 

यह उदाहरण कस्टम प्रतिलिपि हुक को परिभाषित करता है self.spam भी कॉपी की जा रही, के रूप में एक नया उदाहरण यह नए सिरे से गणना करेगा रोकने के लिए।