Invoquer différentes méthodes en python

Question

Bon alors j'ai les suivantes:

Class OwnableObject(MobileObject): 
    def __init__(self, name): 
     MobileObject.__init__(self, name) 
     self.owner = None # not owned 

    def is_ownable(self): return True 
    def is_owned(self): return self.owner 

Quelle est la différence entre l'invocation de la méthode is_ownable sur OwnableObject
et invoquant la méthode is_ownable sur un MobileObject.

Answer 1

Je suppose que cela signifie que le same thing comme dans un langage de programmation qui prend en charge la object oriented paradigm:

>>> class Base: 
...  def ok(self): 
...   print 'OK' 
... 
>>> class SubClass(Base): 
...  def oops(self): 
...   print 'Oops' 
... 
>>> x = SubClass() 
>>> x.ok() 
OK 
>>> 

Answer 2

Mise à jour: Basé sur le code que vous avez posté maintenant, il est impossible d'appeler is_ownable sur un MobileObject parce que le MobileObject ne semble pas avoir de définition pour is_ownable. Dans ce cas, la différence est simplement la différence entre la définition de MobileObject et la définition de OwnableObject. J'ai mis à jour les termes de ce qui suit pour illustrer ce que je veux dire.

Si vous créez une classe en Python (ou dans toutes les langues, vraiment):

class MobileObject(object): 
    def __init__(self, position): 
     self.position = position 
    def move(self, position): 
     self.position = position 
    def is_ownable(self): 
     return False 

Et puis créer une sous-classe:

class OwnableObject(MobileObject): 
    def __init__(self, position, owner=None): 
     MobileObject.__init__(self, position) 
     self.owner = owner 
    def is_ownable(self): 
     return True 
    def is_owned(self): 
     return self.owner 

La sous-classe résultant hérite automatiquement des méthodes de sa superclasse :

movable = MobileObject() 
movable.is_ownable()  # returns False 
movable.move(new_position) # moves movable 
movable.is_owned()   # causes an error 

ownable = OwnableObject() 
ownable.is_ownable()  # returns True 
ownable.move(new_position) # moves ownable 
movable.is_owned()   # returns owner or None 

Comme vous pouvez le voir, et is_ownable()is_owned() diffère entre les deux classes - et dans le dernier cas, puisque is_owned() n'est pas défini, il provoque une erreur lorsqu'il est appelé movable. Mais move() fonctionne de manière identique dans les deux classes.

Answer 3

Toutes les méthodes implémentées dans la classe de base peuvent être appelées dans la sous-classe. L'implémentation de base sera utilisée à moins que vous ne surchargiez la méthode de la sous-classe.