Python usando métodos de otras clases

Question

Si tengo dos clases, y una de ellas tiene una función que quiero usar en mi otra clase, ¿qué uso debo utilizar para no tener que volver a escribir mi función?

Answer 1

Hay dos opciones:

• instanciar un objeto de su clase, a continuación, llamar al método deseado en él
• uso @classmethod para activar una función en un método de la clase

Ejemplo:

class A(object): 
    def a1(self): 
     """ This is an instance method. """ 
     print "Hello from an instance of A" 

    @classmethod 
    def a2(cls): 
     """ This a classmethod. """ 
     print "Hello from class A" 

class B(object): 
    def b1(self): 
     print A().a1() # => prints 'Hello from an instance of A' 
     print A.a2() # => 'Hello from class A' 

O utilizar la herencia, en su caso:

class A(object): 
    def a1(self): 
     print "Hello from Superclass" 

class B(A): 
    pass 

B().a1() # => prints 'Hello from Superclass' 

Answer 2

crea una clase de la cual ambas clases heredan.

Hay herencia múltiple, por lo que si ya tienen un padre no es un problema.

class master(): 
    def stuff (self): 
     pass 

class first (master): 
    pass 


class second (master): 
    pass 


ichi=first() 
ni=second() 

ichi.stuff() 
ni.stuff() 

Answer 3

Existen varios enfoques:

• herencia
• Delegación
• Super-astuto delegación

Los siguientes ejemplos utilizan cada para compartir una función que imprime un miembro.

Herencia

class Common(object): 
    def __init__(self,x): 
     self.x = x 
    def sharedMethod(self): 
     print self.x 

class Alpha(Common): 
    def __init__(self): 
     Common.__init__(self,"Alpha") 

class Bravo(Common): 
    def __init__(self): 
     Common.__init__(self,"Bravo") 

Delegación

class Common(object): 
    def __init__(self,x): 
     self.x = x 
    def sharedMethod(self): 
     print self.x 

class Alpha(object): 
    def __init__(self): 
     self.common = Common("Alpha") 
    def sharedMethod(self): 
     self.common.sharedMethod() 

class Bravo(object): 
    def __init__(self): 
     self.common = Common("Bravo") 
    def sharedMethod(self): 
     self.common.sharedMethod() 

Super-astuto Delegación
Esta solución está basada en el hecho de que no hay nada especial sobre el miembro de Python funciones; puede usar cualquier función u objeto invocable siempre que el primer parámetro se interprete como la instancia de la clase.

def commonPrint(self): 
    print self.x 

class Alpha(object): 
    def __init__(self): 
     self.x = "Alpha" 
    sharedMethod = commonPrint 

class Bravo(object): 
    def __init__(self): 
     self.x = "Bravo" 
    sharedMethod = commonPrint 

O, una forma disimulada de manera similar de lograr una delegación es el uso de un objeto invocable:

class Printable(object): 
    def __init__(self,x): 
     self.x = x 
    def __call__(self): 
     print self.x 

class Alpha(object): 
    def __init__(self): 
     self.sharedMethod = Printable("Alpha") 

class Bravo(object): 
    def __init__(self): 
     self.sharedMethod = Printable("Bravo")