Jak zastąpić operacje kopiowania / głębokiego kopiowania dla obiektu Pythona?

Rozumiem różnicę między copya deepcopyw module kopiowania. Używałem copy.copyi copy.deepcopywcześniej z powodzeniem, ale to jest pierwszy raz, kiedy faktycznie przeładowałem metody __copy__i __deepcopy__. Już Googled się i spojrzał przez wbudowany w modułach Pythona szukać wystąpień __copy__i __deepcopy__funkcji (np sets.py, decimal.pyi fractions.py), ale nadal nie jestem w 100% pewien, że mam rację.

Oto mój scenariusz:

Mam obiekt konfiguracyjny. Początkowo zamierzam utworzyć wystąpienie jednego obiektu konfiguracyjnego z domyślnym zestawem wartości. Ta konfiguracja zostanie przekazana do wielu innych obiektów (aby zapewnić, że wszystkie obiekty będą miały taką samą konfigurację). Jednak po rozpoczęciu interakcji z użytkownikiem każdy obiekt musi niezależnie dostosować swoje konfiguracje, nie wpływając na wzajemne konfiguracje (co mówi mi, że będę musiał wykonać głębokie kopie mojej początkowej konfiguracji).

Oto przykładowy obiekt:

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 

Jaki jest właściwy sposób wdrożenia metod copyi deepcopyna tym obiekcie, aby zapewnić copy.copyi copy.deepcopyzapewnić mi właściwe zachowanie?

Zalecenia dotyczące dostosowywania znajdują się na samym końcu strony z dokumentami :

Klasy mogą używać tych samych interfejsów do sterowania kopiowaniem, których używają do kontrolowania wytrawiania. Zobacz opis modułu pikle, aby uzyskać informacje na temat tych metod. Moduł kopiowania nie korzysta z modułu rejestracji copy_reg.

Aby klasa mogła zdefiniować własną implementację kopii, może zdefiniować specjalne metody __copy__()i __deepcopy__(). Pierwsza jest wezwana do wykonania operacji płytkiego kopiowania; żadne dodatkowe argumenty nie są przekazywane. Ten ostatni jest wywoływany w celu wykonania operacji głębokiego kopiowania; jest przekazywany jeden argument, słownik notatek. Jeśli __deepcopy__() implementacja musi wykonać głęboką kopię komponentu, powinna wywołać deepcopy()funkcję z komponentem jako pierwszym argumentem i słownikiem memo jako drugim argumentem.

Ponieważ wydaje się, że nie zależy Ci na dostosowywaniu marynowania, zdefiniowanie __copy__i __deepcopy__zdecydowanie wydaje się być właściwą drogą dla Ciebie.

W szczególności __copy__(płytka kopia) jest w twoim przypadku dość łatwa ...:

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

__deepcopy__byłoby podobnie (akceptując również memoargument), ale przed powrotem musiałby wywołać self.foo = deepcopy(self.foo, memo)dowolny atrybut, self.fooktóry wymaga głębokiego kopiowania (zasadniczo atrybuty, które są kontenerami - listy, dykty, nieprymitywne obiekty, które przechowują inne rzeczy przez swoje __dict__).

Łącząc odpowiedź Alexa Martellego i komentarz Roba Younga, otrzymujemy następujący kod:

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

wydruki

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

tutaj __deepcopy__wypełnia memodict, aby uniknąć nadmiernego kopiowania w przypadku odniesienia do samego obiektu z jego elementu członkowskiego.

Podążając za doskonałą odpowiedzią Petera , aby zaimplementować niestandardową głęboką kopię, z minimalnymi zmianami w domyślnej implementacji (np. Po prostu zmodyfikuj pole, tak jak potrzebowałem):

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

Z Twojego problemu nie wynika jasno, dlaczego musisz zastąpić te metody, ponieważ nie chcesz dostosowywać metod kopiowania.

W każdym razie, jeśli chcesz dostosować głęboką kopię (np. Udostępniając niektóre atrybuty i kopiując inne), oto rozwiązanie:

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

Mogę być trochę odbiegający od szczegółów, ale proszę bardzo;

Z copydokumentów ;

• Płytka kopia tworzy nowy obiekt złożony, a następnie (w miarę możliwości) wstawia do niego odniesienia do obiektów znalezionych w oryginale.
• Głęboka kopia tworzy nowy obiekt złożony, a następnie rekurencyjnie wstawia do niego kopie obiektów znalezionych w oryginale.

Innymi słowy: copy()skopiuje tylko górny element, a resztę pozostawi jako wskaźniki do oryginalnej struktury. deepcopy()będzie rekurencyjnie kopiować wszystko.

To znaczy, deepcopy()czego potrzebujesz.

Jeśli chcesz zrobić coś naprawdę konkretnego, możesz zastąpić __copy__()lub __deepcopy__(), zgodnie z opisem w instrukcji. Osobiście prawdopodobnie zaimplementowałbym zwykłą funkcję (np. config.copy_config()Lub coś podobnego), aby wyjaśnić, że nie jest to standardowe zachowanie Pythona.

copyModuł wykorzystuje ostatecznie __getstate__()/ protokół staliBejcowanie , więc są one również ważne cele przesłonić.__setstate__()

Domyślna implementacja po prostu zwraca i ustawia __dict__klasę, więc nie musisz dzwonić super()i martwić się sprytną sztuczką Eino Gourdina, powyżej .

Opierając się na czystej odpowiedzi Antony'ego Hatchkinsa, oto moja wersja, w której dana klasa pochodzi z innej klasy niestandardowej (st, musimy zadzwonić 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