পাইথন অবজেক্টের অনুলিপি / ডিপকপি অপারেশন কীভাবে ওভাররাইড করা যায়?

Question 1

আমি মধ্যে পার্থক্য বুঝতে copyবনাম deepcopyকপি মডিউলে। আমি সফলভাবে ব্যবহার করেছি copy.copyএবং এর copy.deepcopyআগেও, তবে এটি প্রথম এবং প্রথমবারের মধ্যে আমি পদ্ধতিগুলি __copy__এবং __deepcopy__পদ্ধতিগুলি ওভারলোডিং সম্পর্কে আসলেই চলেছি । আমি ইতিমধ্যে প্রায় googled এবং মাধ্যমে লাগছিল থাকেন বিল্ট-ইন পাইথন মডিউল দৃষ্টান্ত জন্য চেহারা __copy__এবং __deepcopy__ফাংশন (যেমন sets.py, decimal.pyএবং fractions.py), কিন্তু আমি এখনও না 100% নিশ্চিত আমি এটা ঠিক পেয়েছেন আছি।

এখানে আমার পরিস্থিতি:

আমার একটি কনফিগারেশন অবজেক্ট রয়েছে। প্রাথমিকভাবে, আমি মানগুলির একটি ডিফল্ট সেট সহ একটি কনফিগারেশন অবজেক্ট ইনস্ট্যান্ট করতে যাচ্ছি। এই কনফিগারেশনটি একাধিক অন্যান্য অবজেক্টের কাছে হস্তান্তর করা হবে (সমস্ত কনফিগারেশন একই কনফিগারেশন দিয়ে শুরু হয় তা নিশ্চিত করতে)। তবে, একবার ব্যবহারকারীর মিথস্ক্রিয়া শুরু হয়ে গেলে, প্রতিটি বস্তুর একে অপরের কনফিগারেশনগুলিকে প্রভাবিত না করেই তার কনফিগারেশনগুলি স্বাধীনভাবে টুইঙ্ক করা দরকার (যা আমাকে বলে যে আমার প্রাথমিক কনফিগারেশনটির ডিপকপিসগুলি চারপাশে আনতে হবে)।

এখানে একটি নমুনা অবজেক্ট:

class ChartConfig(object):

    def __init__(self):

        #Drawing properties (Booleans/strings)
        self.antialiased = None
        self.plot_style = None
        self.plot_title = None
        self.autoscale = None

        #X axis properties (strings/ints)
        self.xaxis_title = None
        self.xaxis_tick_rotation = None
        self.xaxis_tick_align = None

        #Y axis properties (strings/ints)
        self.yaxis_title = None
        self.yaxis_tick_rotation = None
        self.yaxis_tick_align = None

        #A list of non-primitive objects
        self.trace_configs = []

    def __copy__(self):
        pass

    def __deepcopy__(self, memo):
        pass

আমাকে সঠিক আচরণ নিশ্চিত করতে এবং দেওয়ার জন্য এই অবজেক্টের পদ্ধতি copyও deepcopyপদ্ধতিগুলি প্রয়োগ করার সঠিক উপায় কী ?copy.copycopy.deepcopy

Question 2

কাস্টমাইজ করার জন্য সুপারিশগুলি ডক্স পৃষ্ঠার একেবারে শেষে রয়েছে :

শ্রেণিগুলি পিকিং নিয়ন্ত্রণ করতে ব্যবহৃত অনুলিপি নিয়ন্ত্রণ করতে একই ইন্টারফেসগুলি ব্যবহার করতে পারে। এই পদ্ধতিগুলির তথ্যের জন্য মডিউল আচারের বিবরণ দেখুন। অনুলিপি মডিউলটি কপির_রেজিস্ট্রেশন মডিউল ব্যবহার করে না।

কোনও শ্রেণীর নিজস্ব অনুলিপি প্রয়োগের সংজ্ঞা দেওয়ার জন্য, এটি বিশেষ পদ্ধতিগুলি __copy__()এবং সংজ্ঞা দিতে পারে __deepcopy__()। প্রাক্তনকে অগভীর অনুলিপি অপারেশন বাস্তবায়নের জন্য ডাকা হয়; কোন অতিরিক্ত যুক্তি পাস করা হয়। পরবর্তীকে গভীর অনুলিপি অপারেশন বাস্তবায়নের জন্য ডাকা হয়; এটি একটি তর্ক, মেমো অভিধান পাস করেছে। যদি __deepcopy__() বাস্তবায়নের জন্য কোনও উপাদানটির গভীর অনুলিপি তৈরি করা দরকার হয় deepcopy()তবে এটিটিকে প্রথম যুক্তি হিসাবে উপাদানটির সাথে ফাংশনটি এবং দ্বিতীয় আর্গুমেন্ট হিসাবে মেমো অভিধানকে কল করা উচিত ।

যেহেতু আপনি পিকিং কাস্টমাইজেশনের বিষয়ে যত্ন করছেন না বলে মনে হয় , সংজ্ঞা দেওয়া __copy__এবং __deepcopy__অবশ্যই আপনার পক্ষে যাওয়ার সঠিক উপায় বলে মনে হচ্ছে।

বিশেষত, __copy__(অগভীর অনুলিপি) আপনার ক্ষেত্রে খুব সহজ ...:

def __copy__(self):
  newone = type(self)()
  newone.__dict__.update(self.__dict__)
  return newone

__deepcopy__অনুরূপ হবে (একটি memoআর্গ গ্রহণ করাও) তবে ফেরার আগে গভীর কপি করা দরকার এমন self.foo = deepcopy(self.foo, memo)কোনও অ্যাট্রিবিউটের জন্য ফোন করতে হবে self.foo(মূলত বৈশিষ্ট্যগুলি যা পাত্রে রয়েছে - তালিকা, ডিক্টস, নন-আদিম বস্তু যা তাদের স্টাফগুলিতে অন্যান্য জিনিস রাখে __dict__)।

Question 3

অ্যালেক্স মার্তেলির উত্তর এবং রব ইয়ংয়ের মন্তব্য একসাথে রাখলে আপনি নিম্নলিখিত কোডটি পেয়েছেন:

from copy import copy, deepcopy

class A(object):
    def __init__(self):
        print 'init'
        self.v = 10
        self.z = [2,3,4]

    def __copy__(self):
        cls = self.__class__
        result = cls.__new__(cls)
        result.__dict__.update(self.__dict__)
        return result

    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            setattr(result, k, deepcopy(v, memo))
        return result

a = A()
a.v = 11
b1, b2 = copy(a), deepcopy(a)
a.v = 12
a.z.append(5)
print b1.v, b1.z
print b2.v, b2.z

প্রিন্ট

init
11 [2, 3, 4, 5]
11 [2, 3, 4]

বস্তুটি নিজেই এর সদস্য থেকে রেফারেন্স করা হলে অতিরিক্ত অনুলিপি এড়াতে এখানে __deepcopy__ডিকটি পূরণ memoকরে।

Question 4

পিটারের দুর্দান্ত উত্তরের অনুসরণ করে , একটি কাস্টম ডিপকপি বাস্তবায়নের জন্য, ডিফল্ট বাস্তবায়নের ন্যূনতম পরিবর্তন সহ (যেমন, আমার প্রয়োজন মতো একটি ক্ষেত্রটি পরিবর্তন করা):

class Foo(object):
    def __deepcopy__(self, memo):
        deepcopy_method = self.__deepcopy__
        self.__deepcopy__ = None
        cp = deepcopy(self, memo)
        self.__deepcopy__ = deepcopy_method
        cp.__deepcopy__ = deepcopy_method

        # custom treatments
        # for instance: cp.id = None

        return cp

Question 5

আপনি কেন অনুলিপি পদ্ধতিতে কোনও কাস্টমাইজেশন করতে চান না তাই আপনার সমস্যাগুলি থেকে আপনার কেন এই পদ্ধতিগুলিকে ওভাররাইড করা প্রয়োজন তা পরিষ্কার নয়।

যাইহোক, আপনি যদি ডিপ কপিটি কাস্টমাইজ করতে চান (যেমন কিছু বৈশিষ্ট্য ভাগ করে অন্যকে অনুলিপি করে), তবে এখানে একটি সমাধান রয়েছে:

from copy import deepcopy


def deepcopy_with_sharing(obj, shared_attribute_names, memo=None):
    '''
    Deepcopy an object, except for a given list of attributes, which should
    be shared between the original object and its copy.

    obj is some object
    shared_attribute_names: A list of strings identifying the attributes that
        should be shared between the original and its copy.
    memo is the dictionary passed into __deepcopy__.  Ignore this argument if
        not calling from within __deepcopy__.
    '''
    assert isinstance(shared_attribute_names, (list, tuple))
    shared_attributes = {k: getattr(obj, k) for k in shared_attribute_names}

    if hasattr(obj, '__deepcopy__'):
        # Do hack to prevent infinite recursion in call to deepcopy
        deepcopy_method = obj.__deepcopy__
        obj.__deepcopy__ = None

    for attr in shared_attribute_names:
        del obj.__dict__[attr]

    clone = deepcopy(obj)

    for attr, val in shared_attributes.iteritems():
        setattr(obj, attr, val)
        setattr(clone, attr, val)

    if hasattr(obj, '__deepcopy__'):
        # Undo hack
        obj.__deepcopy__ = deepcopy_method
        del clone.__deepcopy__

    return clone



class A(object):

    def __init__(self):
        self.copy_me = []
        self.share_me = []

    def __deepcopy__(self, memo):
        return deepcopy_with_sharing(self, shared_attribute_names = ['share_me'], memo=memo)

a = A()
b = deepcopy(a)
assert a.copy_me is not b.copy_me
assert a.share_me is b.share_me

c = deepcopy(b)
assert c.copy_me is not b.copy_me
assert c.share_me is b.share_me

Question 6

আমি বিশেষ কিছুটা বন্ধ হতে পারে, কিন্তু এখানে যায়;

copyডক্স থেকে ;

একটি অগভীর অনুলিপি একটি নতুন যৌগিক অবজেক্ট তৈরি করে এবং তারপরে (সম্ভাব্য পরিমাণে) মূলটিতে পাওয়া বস্তুগুলির মধ্যে রেফারেন্স সন্নিবেশ করায়।

একটি গভীর অনুলিপি একটি নতুন যৌগিক বস্তু তৈরি করে এবং তারপরে, পুনরাবৃত্তভাবে, মূলটিতে পাওয়া বস্তুর মধ্যে অনুলিপি সন্নিবেশ করায়।

অন্য কথায়: copy()কেবলমাত্র শীর্ষ উপাদানটি অনুলিপি করবে এবং বাকীটিকে মূল কাঠামোর মধ্যে পয়েন্টার হিসাবে রেখে দেবে। deepcopy()পুনরাবৃত্তভাবে সব কিছু অনুলিপি করা হবে।

অর্থাৎ deepcopy()আপনার যা প্রয়োজন তা হল।

আপনার যদি সত্যই নির্দিষ্ট কিছু করার দরকার হয় তবে ম্যানুয়ালটিতে বর্ণিত হিসাবে আপনি ওভাররাইড করতে পারেন __copy__()বা করতে পারেন __deepcopy__()। ব্যক্তিগতভাবে, আমি সম্ভবত এটি একটি সরল ফাংশন (উদাহরণস্বরূপ config.copy_config()বা এ জাতীয়) বাস্তবায়িত করব যাতে এটি পাইথন স্ট্যান্ডার্ড আচরণ নয় plain

Question 7

copyমডিউল ব্যবহার অবশেষে __getstate__()/ pickling প্রোটোকল__setstate__() , তাই এই এছাড়াও ওভাররাইড করতে বৈধ লক্ষ্যমাত্রা আছে।

ডিফল্ট বাস্তবায়ন কেবল __dict__ক্লাসের সেটগুলি ফিরিয়ে দেয় এবং সেট করে , সুতরাং উপরেরsuper() , আপনাকে ইয়নো গৌরিনের চতুর কৌশল সম্পর্কে কল করতে এবং চিন্তিত হতে হবে না ।

Question 8

অ্যান্টনি হ্যাচকিন্সের শুদ্ধ উত্তরের উপর ভিত্তি করে তৈরি করা, আমার সংস্করণটি এখানে রয়েছে যেখানে প্রশ্নে ক্লাসটি অন্য কাস্টম শ্রেণীর (আমাদের কাছে কল করা দরকার super) থেকে উদ্ভূত :

class Foo(FooBase):
    def __init__(self, param1, param2):
        self._base_params = [param1, param2]
        super(Foo, result).__init__(*self._base_params)

    def __copy__(self):
        cls = self.__class__
        result = cls.__new__(cls)
        result.__dict__.update(self.__dict__)
        super(Foo, result).__init__(*self._base_params)
        return result

    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            setattr(result, k, copy.deepcopy(v, memo))
        super(Foo, result).__init__(*self._base_params)
        return result