Bir Python nesnesi için kopyalama / derin kopya işlemlerini nasıl geçersiz kılınır?

Ben arasındaki farkı anlamak copyvs. deepcopykopya modülünde. Daha önce copy.copyve copy.deepcopybaşarıyla kullandım , ancak ilk kez gerçekten __copy__ve __deepcopy__yöntemlerini aşırı yüklemeye başladım . Zaten yoluyla etrafına Googled ve baktım örnekleri aramaya Python modülleri dahili __copy__ve __deepcopy__fonksiyonları (örn sets.py, decimal.pyve fractions.py), ama yine de% 100 emin ben doğru var benim.

İşte benim senaryom:

Bir yapılandırma nesnem var. Başlangıçta, bir yapılandırma nesnesini varsayılan bir değerler kümesiyle başlatacağım. Bu konfigürasyon, diğer birçok nesneye devredilecektir (tüm nesnelerin aynı konfigürasyonla başlamasını sağlamak için). Bununla birlikte, kullanıcı etkileşimi başladığında, her nesnenin, birbirlerinin konfigürasyonlarını etkilemeden kendi konfigürasyonlarını bağımsız olarak ayarlaması gerekir (bu bana, başkalarını teslim etmek için ilk konfigürasyonumun derin kopyalarını yapmam gerektiğini söylüyor).

İşte örnek bir nesne:

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 

Bana uygun davranışı sağlamak ve vermek için bu nesne üzerinde copyve deepcopyyöntemlerini uygulamanın doğru yolu nedir ?copy.copycopy.deepcopy

Özelleştirme önerileri, dokümanlar sayfasının en sonundadır :

Sınıflar, asitlemeyi kontrol etmek için kullandıkları kopyalamayı kontrol etmek için aynı arayüzleri kullanabilir. Bu yöntemler hakkında bilgi için modül turşusu açıklamasına bakın. Kopyalama modülü copy_reg kayıt modülünü kullanmaz.

Bir sınıfın kendi kopya uygulamasını tanımlaması için özel yöntemler __copy__()ve __deepcopy__(). İlki, sığ kopyalama işlemini uygulamaya çağırılır; hiçbir ek argüman iletilmez. İkincisi, derin kopyalama işlemini gerçekleştirmek için çağrılır; bir argüman aktarılır, not sözlüğü. Eğer __deepcopy__() uygulama bir bileşenin derin bir kopyasını yapmak gerekiyor, bu aramalısınız deepcopy()birinci argüman ve ikinci argüman olarak not sözlük olarak bileşenle fonksiyonunu.

Asitleme özelleştirme ile ilgilenmiyor göründüğünüz için, tanımlama __copy__ve __deepcopy__kesinlikle sizin için doğru yol gibi görünüyor.

Özellikle, __copy__(sığ kopya) sizin durumunuzda oldukça kolaydır ...:

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

__deepcopy__benzer olacaktır (bir memoargümanı kabul etmek de) ancak dönüşten önce derin kopyalamaya ihtiyaç duyan self.foo = deepcopy(self.foo, memo)herhangi bir özniteliği self.foo(esasen kaplar olan öznitelikler - listeler, diktler, diğer şeyleri kendi listelerinde tutan ilkel olmayan nesneler) çağırması gerekir __dict__.

Alex Martelli'nin cevabı ile Rob Young'un yorumunu bir araya getirerek aşağıdaki kodu elde edersiniz:

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

baskılar

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

burada , nesnenin üyesinden referans alınması durumunda fazla kopyalamadan kaçınmak __deepcopy__için memodikte doldurulur .

Peter'ın mükemmel cevabının ardından , varsayılan uygulamada en az değişiklikle özel bir derin kopya uygulamak için (örneğin, sadece ihtiyacım olduğu gibi bir alanı değiştirmek):

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

Kopyalama yöntemlerinde herhangi bir özelleştirme yapmak istemediğinizden, neden bu yöntemleri geçersiz kılmanız gerektiğine dair sorununuz net değil.

Her neyse, derin kopyayı özelleştirmek istiyorsanız (örneğin, bazı öznitelikleri paylaşıp diğerlerini kopyalayarak), işte bir çözüm:

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

Ayrıntılardan biraz uzak olabilirim ama işte burada;

Gönderen copydocs ;

• Yüzeysel bir kopya yeni bir bileşik nesne oluşturur ve ardından (mümkün olduğu ölçüde) orijinalde bulunan nesnelere referanslar ekler.
• Derin bir kopya yeni bir bileşik nesne oluşturur ve ardından orijinalde bulunan nesnelerin kopyalarını yinelemeli olarak ona ekler.

Başka bir deyişle: copy()yalnızca en üstteki öğeyi kopyalayacak ve geri kalanını orijinal yapıya işaretçiler olarak bırakacaktır. deepcopy()özyinelemeli olarak her şeyi kopyalar.

Yani deepcopy()ihtiyacın olan şey bu.

Gerçekten spesifik bir şey yapmanız gerekiyorsa , kılavuzda açıklandığı gibi __copy__()veya geçersiz kılabilirsiniz __deepcopy__(). Şahsen, config.copy_config()Python standart davranışı olmadığını açıklığa kavuşturmak için muhtemelen düz bir işlev (örneğin veya benzeri) uygulayabilirim.

copyModül sonunda kullandığı __getstate__()/ dekapaj protokolü bunlar da geçersiz kılma için geçerli hedeflerdir, bu yüzden.__setstate__()

Varsayılan uygulama yalnızca __dict__sınıfın super()adını döndürür ve ayarlar , böylece yukarıda , Eino Gourdin'in akıllı numarası hakkında endişelenmenize gerek kalmaz .

Antony Hatchkins'in temiz cevabına dayanarak, işte söz konusu sınıfın başka bir özel sınıftan türetildiği sürümüm (st aramamız gerekir 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