web-dev-qa-db-fra.com

Comment copier une instance de classe en python?

Je voudrais faire une copie d'une instance de classe en python. J'ai essayé copy.deepcopy mais le message d'erreur suivant s'affiche:

RuntimeError: seules les variables créées explicitement par l'utilisateur (feuilles de graphe) prennent actuellement en charge le protocole deepcopy.

Donc supposons que j'ai quelque chose comme:

class C(object):
    def __init__(self,a,b, **kwargs):
        self.a=a
        self.b=b
        for x, v in kwargs.items():
            setattr(self, x, v)

c = C(4,5,'r'=2)
c.a = 11
del c.b

Et maintenant, je veux créer une copie complète identique de c, existe-t-il un moyen simple?

pythonclassdeep-copy
6
patapouf_ai

Je l'ai surtout compris. Le seul problème que je ne puisse pas surmonter est de connaître un ensemble acceptable d'arguments d'initialisation (arguments pour __init__) pour toutes les classes. Je dois donc faire les deux hypothèses suivantes:

1) J'ai un ensemble d'arguments par défaut pour la classe C que j'appelle argsC. 2) Tous les objets de C peuvent être initialisés avec des arguments vides.

Dans ce cas, je peux Premier : Initialiser une nouvelle instance de la classe C à partir de son instance que je veux copier, c:

c_copy = c.__class__(**argsC)

Deuxième : Passez en revue tous les attributs de c et définissez-les comme c_copy de manière à être une copie des attributs de c

for att in c.__dict__:
    setattr(c_copy, att, object_copy(getattr(c,att)))

où object_copy est une application récursive de la fonction que nous construisons.

Last : Supprimez tous les attributs dans c_copy mais pas dans c:

for att in c_copy.__dict__:
    if not hasattr(c, att):
        delattr(c_copy, att)

En réunissant tout cela, nous avons:

import copy

def object_copy(instance, init_args=None):
    if init_args:
        new_obj = instance.__class__(**init_args)
    else:
        new_obj = instance.__class__()
    if hasattr(instance, '__dict__'):
        for k in instance.__dict__ :
            try:
                attr_copy = copy.deepcopy(getattr(instance, k))
            except Exception as e:
                attr_copy = object_copy(getattr(instance, k))
            setattr(new_obj, k, attr_copy)

        new_attrs = list(new_obj.__dict__.keys())
        for k in new_attrs:
            if not hasattr(instance, k):
                delattr(new_obj, k)
        return new_obj
    else:
        return instance

Donc, en mettant tout cela ensemble, nous avons:

argsC = {'a':1, 'b':1}
c = C(4,5,r=[[1],2,3])
c.a = 11
del c.b
c_copy = object_copy(c, argsC)
c.__dict__

{'a': 11, 'r': [[1], 2, 3]}

c_copy.__dict__

{'a': 11, 'r': [[1], 2, 3]}

c.__dict__

{'a': 11, 'r': [[1, 33], 2, 3]}

c_copy.__dict__

{'a': 11, 'r': [[1], 2, 3]}

Quel est le résultat souhaité? Il utilise deepcopy s'il le peut, mais dans les cas où il déclencherait une exception, il peut s'en passer.

1
patapouf_ai

Une façon de le faire consiste à implémenter __copy__ dans la classe C comme ceci:

class A:
    def __init__(self):
        self.var1 = 1
        self.var2 = 2
        self.var3 = 3

class C(A):
    def __init__(self, a=None, b=None, **kwargs):
        super().__init__()
        self.a = a
        self.b = b
        for x, v in kwargs.items():
            setattr(self, x, v)

    def __copy__(self):
        self.normalizeArgs()
        return C(self.a, self.b, kwargs=self.kwargs)

    # THIS IS AN ADDITIONAL GATE-KEEPING METHOD TO ENSURE 
    # THAT EVEN WHEN PROPERTIES ARE DELETED, CLONED OBJECTS
    # STILL GETS DEFAULT VALUES (NONE, IN THIS CASE)
    def normalizeArgs(self):
        if not hasattr(self, "a"):
            self.a      = None
        if not hasattr(self, "b"):
            self.b      = None
        if not hasattr(self, "kwargs"):
            self.kwargs = {}

cMain   = C(a=4, b=5, kwargs={'r':2})

del cMain.b
cClone  = cMain.__copy__()

cMain.a = 11

del  cClone.b
cClone2 = cClone.__copy__()

print(vars(cMain))
print(vars(cClone))
print(vars(cClone2))

 enter image description here

4
Poiz

Oui, vous pouvez faire une copie d'une instance de classe en utilisant deepcopy:

from copy import deepcopy

c = C(4,5,'r'=2)
d = deepcopy(c)

Cela crée la copie de l'instance de classe 'c' dans 'd'.

2
Usman