Python utilisant des méthodes d'autres classes

Question

Si j'ai deux classes, et que l'une d'entre elles a une fonction que je veux utiliser dans mon autre classe, qu'est-ce que j'utilise pour ne pas avoir à réécrire ma fonction?

Answer 1

Il y a deux options:

• instancie un objet dans votre classe, puis appelez la méthode souhaitée sur ce
• utilisation @classmethod pour transformer une fonction dans une méthode de classe

Exemple:

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' 

Ou utiliser l'héritage, le cas échéant:

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

class B(A): 
    pass 

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

Answer 2

Vous créez une classe à partir de laquelle les deux classes héritent.

Il existe plusieurs héritages, donc s'ils ont déjà un parent, ce n'est pas un problème.

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

class first (master): 
    pass 


class second (master): 
    pass 


ichi=first() 
ni=second() 

ichi.stuff() 
ni.stuff() 

Answer 3

Il existe plusieurs approches:

• héritage
• Délégation
• délégation Super-sournoise

Les exemples suivants utilisent chaque pour partager une fonction qui imprime un membre.

héritage

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

Délégation

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-sournoise Délégation
Cette solution est basé sur le fait qu'il n'y a rien de spécial à propos de membre Python les fonctions; vous pouvez utiliser n'importe quelle fonction ou objet appelable tant que le premier paramètre est interprété comme l'instance de la classe.

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 

Ou, de manière tout aussi sournoise de la délégation réalisation est d'utiliser un objet appelable:

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