Як замінити операції копіювання / глибокого копіювання для об'єкта Python?

Я розумію різницю між модулем копіювання copyта проти deepcopy. Я використовував copy.copyі copy.deepcopyраніше успішно, але це перший раз, коли я насправді перейшов до перевантаження методів __copy__і __deepcopy__. Я вже Гугл і подивився через вбудовані модулі Python шукати екземпляри __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.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).

Складаючи відповідь Алекса Мартеллі та коментар Роба Янга, ви отримуєте такий код:

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дикт, щоб уникнути надмірного копіювання у випадку, якщо на сам об’єкт посилається його член.

Слідуючи чудовій відповіді Пітера , застосувати власну глибоку копію з мінімальними змінами до стандартної реалізації (наприклад, просто модифікуючи поле, як мені потрібно):

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()і турбуватися про розумний трюк Ейно Гурдіна вище .

Спираючись на чітку відповідь Ентоні Хеткінса, ось моя версія, де відповідний клас походить від іншого користувацького класу (st, який нам потрібно зателефонувати 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