Copia costruttore in python?

Question

Esiste un costruttore di copia in python? Se no, cosa dovrei fare per ottenere qualcosa di simile?

La situazione è che sto utilizzando una libreria e ho ampliato una delle classi con funzionalità aggiuntive e voglio essere in grado di convertire gli oggetti che ottengo dalla libreria alle istanze della mia classe.

Answer 1

penso che si desidera che il copy module

import copy 

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

è possibile controllare la copia più o meno allo stesso modo in cui si controlla pickle.

Answer 2

Per la situazione, suggerirei di scrivere un metodo di classe (o potrebbe essere un metodo statico o una funzione separata) che accetta come argomento un'istanza della classe della libreria e restituisce un'istanza della classe con tutti gli attributi applicabili copiato.

Answer 3

In python il costruttore di copie può essere definito utilizzando argomenti predefiniti. Diciamo che volete che il normale costruttore esegua la funzione non_copy_constructor(self) e che il costruttore di copia debba essere eseguito copy_constructor(self, orig). Quindi è possibile effettuare le seguenti operazioni:

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 semplice esempio di mio solito realizzazione di un costruttore di 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

Sulla @ Godsmith di train of thought e affrontare @ necessità di Zitrax (credo) a fare la copia dei dati per tutti gli attributi all'interno del costruttore:

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)) 

Questa classe ConfusionMatrix eredita un pandas.DataFrame e aggiunge una tonnellata di altri attribut es e metodi che devono essere ricalcolati a meno che non sia possibile copiare i dati della matrice other. Alla ricerca di una soluzione è come ho trovato questa domanda.

Answer 6

Ho una situazione simile diversa per il fatto che la nuova classe deve solo copiare gli attributi. Così usando @ idea di Dunham e l'aggiunta di alcune specificità @ di meisterluk suggerimento, @ metodo "copy_constructor" di meisterluk potrebbe essere:

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 

L'output:

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


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