¿Copiar constructor en python?

Question

¿Hay un constructor de copias en python? Si no, ¿qué haría para lograr algo similar?

La situación es que estoy usando una biblioteca y he ampliado una de las clases con funcionalidad adicional y quiero poder convertir los objetos que obtengo de la biblioteca en instancias de mi propia clase.

Answer 1

creo que desea que el copy module

import copy 

x = copy.copy(y)  # make a shallow copy of y 
x = copy.deepcopy(y) # make a deep copy of y 

se puede controlar la copia de la misma manera que usted controla pickle.

Answer 2

Para su situación, sugeriría escribir un método de clase (o podría ser un método estático o una función separada) que toma como argumento una instancia de la clase de la biblioteca y devuelve una instancia de su clase con todos los atributos aplicables copiado.

Answer 3

En python, el constructor de copia se puede definir utilizando argumentos predeterminados. Digamos que quiere que el constructor normal ejecute la función non_copy_constructor(self) y el constructor de copia debería ejecutar copy_constructor(self, orig). A continuación, puede hacer lo siguiente:

class Foo: 
    def __init__(self, orig=None): 
     if orig is None: 
      self.non_copy_constructor() 
     else: 
      self.copy_constructor(orig) 
    def non_copy_constructor(self): 
     # do the non-copy constructor stuff 
    def copy_constructor(self, orig): 
     # do the copy constructor 

a=Foo() # this will call the non-copy constructor 
b=Foo(a) # this will call the copy constructor 

Answer 4

Un ejemplo sencillo de mi aplicación habitual de un constructor de copia:

import copy 

class Foo: 

    def __init__(self, data): 
    self._data = data 

    @classmethod 
    def from_foo(cls, class_instance): 
    data = copy.deepcopy(class_instance._data) # if deepcopy is necessary 
    return cls(data) 

Answer 5

Sobre la base @ Godsmith de train of thought y abordar @ necesidad de Zitrax (creo) para hacer el copia de datos para todos los atributos dentro del constructor:

class ConfusionMatrix(pd.DataFrame): 
    def __init__(self, df, *args, **kwargs): 
     try: 
      # Check if `df` looks like a `ConfusionMatrix` 
      # Could check `isinstance(df, ConfusionMatrix)` 
      # But might miss some "ConfusionMatrix-elligible" `DataFrame`s 
      assert((df.columns == df.index).all()) 
      assert(df.values.dtype == int) 
      self.construct_copy(df, *args, **kwargs) 
      return 
     except (AssertionError, AttributeError, ValueError): 
      pass 
     # df is just data, so continue with normal constructor here ... 

    def construct_copy(self, other, *args, **kwargs): 
     # construct a parent DataFrame instance 
     parent_type = super(ConfusionMatrix, self) 
     parent_type.__init__(other) 
     for k, v in other.__dict__.iteritems(): 
      if hasattr(parent_type, k) and hasattr(self, k) and getattr(parent_type, k) == getattr(self, k): 
       continue 
      setattr(self, k, deepcopy(v)) 

Esta clase hereda una ConfusionMatrixpandas.DataFrame y añade un montón de otra attribut es y métodos que deben ser recalculados a menos que se puedan copiar los datos de la matriz other. Buscando una solución es cómo encontré esta pregunta.

Answer 6

Tengo una situación similar, ya que la nueva clase solo necesita copiar atributos. Por lo tanto usando @ idea de Dunham y añadiendo alguna especificidad a la sugerencia de @ meisterluk, el método "copy_constructor" de meisterluk @ podría ser:

from copy import deepcopy 
class Foo(object): 
    def __init__(self, myOne=1, other=None): 
    self.two = 2 
    if other <> None: 
     assert isinstance(other, Foo), "can only copy instances of Foo" 
     self.__dict__ = deepcopy(other.__dict__) 
    self.one = myOne 

def __repr__(self): 
    out = '' 
    for k,v in self.__dict__.items(): 
     out += '{:>4s}: {}, {}\n'.format(k,v.__class__,v) 
    return out 

def bar(self): 
    pass 

foo1 = Foo() 
foo2 = Foo('one', foo1) 

print '\nfoo1\n',foo1 
print '\nfoo2\n',foo2 

La salida:

foo1 
two: <type 'int'>, 2 
one: <type 'int'>, 1 


foo2 
two: <type 'int'>, 2 
one: <type 'str'>, one