Héritage Python - comment désactiver une fonction

Question

En C++, vous pouvez désactiver une fonction dans la classe parent en la déclarant privée dans la classe enfant. Comment cela peut-il être fait en Python? C'EST À DIRE. Comment puis-je cacher la fonction du parent de l'interface publique de l'enfant?

Answer 1

Il n'y a pas vraiment vrai « privé » attributs ou méthodes en Python . Une chose que vous pouvez faire est de remplacer simplement la méthode que vous ne voulez pas dans la sous-classe, et soulever une exception:

>>> class Foo(object): 
...  def foo(self): 
...   print 'FOO!' 
...   
>>> class Bar(Foo): 
...  def foo(self): 
...   raise AttributeError("'Bar' object has no attribute 'foo'") 
...  
>>> b = Bar() 
>>> b.foo() 
Traceback (most recent call last): 
    File "<interactive input>", line 1, in <module> 
    File "<interactive input>", line 3, in foo 
AttributeError: 'Bar' object has no attribute 'foo' 

Answer 2

class X(object): 
    def some_function(self): 
     do_some_stuff() 

class Y(object): 
    some_function = None 

Cela peut conduire à une mauvaise et difficile à trouver des exceptions étant jetés, donc vous pouvez essayer ceci:

class X(object): 
    def some_function(self): 
     do_some_stuff() 

class Y(object): 
    def some_function(self): 
     raise NotImplementedError("function some_function not implemented") 

Answer 3

méthode de Kurosch de résoudre le problème est pas tout à fait correct, parce que vous pouvez toujours utiliser b.foo sans obtenir un AttributeError. Si vous n'appelez pas la fonction, aucune erreur ne se produit. Voici deux façons que je peux penser à faire:

import doctest 

class Foo(object): 
    """ 
    >>> Foo().foo() 
    foo 
    """ 
    def foo(self): print 'foo' 
    def fu(self): print 'fu' 

class Bar(object): 
    """ 
    >>> b = Bar() 
    >>> b.foo() 
    Traceback (most recent call last): 
    ... 
    AttributeError 
    >>> hasattr(b, 'foo') 
    False 
    >>> hasattr(b, 'fu') 
    True 
    """ 
    def __init__(self): self._wrapped = Foo() 

    def __getattr__(self, attr_name): 
     if attr_name == 'foo': raise AttributeError 
     return getattr(self._wrapped, attr_name) 

class Baz(Foo): 
    """ 
    >>> b = Baz() 
    >>> b.foo() # doctest: +ELLIPSIS 
    Traceback (most recent call last): 
    ... 
    AttributeError... 
    >>> hasattr(b, 'foo') 
    False 
    >>> hasattr(b, 'fu') 
    True 
    """ 
    foo = property() 

if __name__ == '__main__': 
    doctest.testmod() 

Bar utilise le motif « envelopper » pour restreindre l'accès à l'objet enveloppé. Martelli has a good talk traitant de cela. Baz utilise the property built-in pour implémenter le protocole descripteur pour l'attribut à remplacer.

Answer 4

C'est la façon la plus propre que je connaisse de le faire. Remplacez les méthodes et demandez à chacune des méthodes surchargées d'appeler votre méthode disabledmethods(). Comme ceci:

class Deck(list): 
... 
@staticmethod 
    def disabledmethods(): 
     raise Exception('Function Disabled') 
    def pop(self): Deck.disabledmethods() 
    def sort(self): Deck.disabledmethods() 
    def reverse(self): Deck.disabledmethods() 
    def __setitem__(self, loc, val): Deck.disabledmethods() 

Answer 5

Une variante de la réponse de Kurosch:

class Foo(object): 
    def foo(self): 
     print 'FOO!' 

class Bar(Foo): 
    @property 
    def foo(self): 
     raise AttributeError("'Bar' object has no attribute 'foo'") 

b = Bar() 
b.foo 

Cela soulève une AttributeError sur la propriété au lieu du moment où la méthode est appelée.

Je l'aurais suggéré dans un commentaire mais malheureusement je n'en ai pas encore la réputation.