จะลบล้างการดำเนินการคัดลอก / deepcopy สำหรับวัตถุ Python ได้อย่างไร

ฉันเข้าใจความแตกต่างระหว่างcopyเทียบกับdeepcopyในโมดูลการคัดลอก ฉันเคยใช้มาก่อนcopy.copyและcopy.deepcopyประสบความสำเร็จ แต่นี่เป็นครั้งแรกที่ฉันได้ใช้งาน__copy__และ__deepcopy__วิธีการมากเกินไป ฉัน Googled แล้วรอบ ๆ และมองผ่านโมดูลในตัวงูหลามที่จะมองหาอินสแตนซ์ของ__copy__และ__deepcopy__ฟังก์ชั่น (เช่นsets.py, decimal.pyและfractions.py) แต่ฉันยังคงไม่แน่ใจ 100% ผมเคยได้มันขวา

นี่คือสถานการณ์ของฉัน:

ฉันมีวัตถุการกำหนดค่า ในขั้นต้นฉันจะสร้างอินสแตนซ์วัตถุการกำหนดค่าหนึ่งรายการด้วยชุดค่าเริ่มต้น การกำหนดค่านี้จะถูกส่งต่อไปยังวัตถุอื่น ๆ หลายรายการ (เพื่อให้แน่ใจว่าวัตถุทั้งหมดเริ่มต้นด้วยการกำหนดค่าเดียวกัน) อย่างไรก็ตามเมื่อการโต้ตอบกับผู้ใช้เริ่มต้นขึ้นแต่ละออบเจ็กต์จะต้องปรับแต่งการกำหนดค่าโดยอิสระโดยไม่ส่งผลกระทบต่อการกำหนดค่าของกันและกัน (ซึ่งบอกว่าฉันจะต้องสร้าง deepcopys ของการกำหนดค่าเริ่มต้นของฉันเพื่อส่งต่อ)

นี่คือวัตถุตัวอย่าง:

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.copyและcopy.deepcopyให้พฤติกรรมที่เหมาะสมแก่ฉัน

คำแนะนำสำหรับการปรับแต่งอยู่ที่ท้ายสุดของหน้าเอกสาร :

คลาสสามารถใช้อินเทอร์เฟซเดียวกันเพื่อควบคุมการคัดลอกที่ใช้ควบคุมการดอง ดูคำอธิบายของโมดูลดองสำหรับข้อมูลเกี่ยวกับวิธีการเหล่านี้ โมดูลการคัดลอกไม่ใช้โมดูลการลงทะเบียน copy_reg

ในการสั่งซื้อสำหรับการเรียนเพื่อกำหนดดำเนินงานสำเนาของตัวเองก็สามารถกำหนดวิธีการพิเศษและ__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__s)

การรวบรวมคำตอบของ Alex Martelli และความคิดเห็นของ Rob Young เข้าด้วยกันคุณจะได้รับรหัสต่อไปนี้:

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เพื่อหลีกเลี่ยงการคัดลอกมากเกินไปในกรณีที่ออบเจ็กต์ถูกอ้างอิงจากสมาชิก

ทำตามคำตอบที่ยอดเยี่ยมของ Peterเพื่อใช้งาน Deepcopy ที่กำหนดเองโดยมีการปรับเปลี่ยนการใช้งานเริ่มต้นเพียงเล็กน้อย (เช่นเพียงแค่แก้ไขฟิลด์ตามที่ฉันต้องการ):

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

ยังไม่ชัดเจนจากปัญหาของคุณว่าทำไมคุณถึงต้องแทนที่วิธีการเหล่านี้เนื่องจากคุณไม่ต้องการปรับแต่งวิธีการคัดลอกใด ๆ

อย่างไรก็ตามหากคุณต้องการปรับแต่งสำเนาลึก (เช่นโดยการแบ่งปันคุณสมบัติบางอย่างและคัดลอกผู้อื่น) นี่คือวิธีแก้ปัญหา:

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

ฉันอาจจะไม่ค่อยสนใจเรื่องเฉพาะ แต่นี่ไป;

จากcopyเอกสาร ;

• สำเนาตื้นสร้างวัตถุผสมใหม่จากนั้น (เท่าที่จะทำได้) แทรกการอ้างอิงลงในวัตถุที่พบในต้นฉบับ
• สำเนาลึกจะสร้างวัตถุผสมใหม่จากนั้นใส่สำเนาซ้ำลงในวัตถุที่พบในต้นฉบับ

กล่าวอีกนัยหนึ่ง: copy()จะคัดลอกเฉพาะองค์ประกอบด้านบนและปล่อยให้ส่วนที่เหลือเป็นตัวชี้ในโครงสร้างดั้งเดิมdeepcopy()จะคัดลอกซ้ำ ๆ ทุกอย่าง

นั่นคือ, deepcopy()สิ่งที่คุณต้องการ

หากคุณต้องการทำบางสิ่งที่เฉพาะเจาะจงจริงๆคุณสามารถลบล้าง__copy__()หรือ__deepcopy__()ตามที่อธิบายไว้ในคู่มือ โดยส่วนตัวแล้วฉันอาจใช้ฟังก์ชันธรรมดา (เช่นconfig.copy_config()หรือเช่นนั้น) เพื่อทำให้ชัดเจนว่าไม่ใช่พฤติกรรมมาตรฐานของ Python

copyโมดูลใช้ในที่สุด__getstate__()/ ดองโปรโตคอลดังนั้นเหล่านี้ยังมีเป้าหมายที่ถูกต้องเพื่อแทนที่__setstate__()

เริ่มต้นใช้งานเพียงแค่ผลตอบแทนและชุด__dict__ชั้นดังนั้นคุณจึงไม่ต้องโทรsuper()และกังวลเกี่ยวกับเคล็ดลับฉลาด Eino Gourdin ของดังกล่าวข้างต้น

จากคำตอบที่ชัดเจนของ Antony Hatchkins นี่คือเวอร์ชันของฉันที่คลาสที่เป็นปัญหามาจากคลาสที่กำหนดเองอื่น (เราต้องเรียก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