Herencia de Python: cómo deshabilitar una función

Question

En C++, puede deshabilitar una función en la clase principal al declararla como privada en la clase secundaria. ¿Cómo se puede hacer esto en Python? ES DECIR. ¿Cómo puedo ocultar la función de los padres desde la interfaz pública del niño?

Answer 1

Realmente no hay ninguna verdad "privado" atributos o métodos en Python . Una cosa que puede hacer es simplemente reemplazar el método no desea en la subclase, y elevar una excepción: Método

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

Esto puede conducir a una cierta desagradable y difícil de encontrar excepciones ser lanzado sin embargo, por lo que podría intentar esto:

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

de kurosch de resolver el problema no es del todo correcto, porque todavía puede utilizar sin b.foo obteniendo un AttributeError. Si no invocas la función, no se produce ningún error. Aquí hay dos maneras que se me ocurre de hacerlo:

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 utiliza el patrón de "envolver" para restringir el acceso al objeto envuelto. Martelli has a good talk que trata de esto. Baz usa the property built-in para implementar el protocolo descriptor para el atributo anular.

Answer 4

Esta es la manera más limpia que conozco para hacerlo.

Reemplace los métodos y haga que cada uno de los métodos reemplazados invoque su método disabledmethods(). De esta manera:

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

Una variación en la respuesta 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 

Esto plantea una AttributeError en la propiedad en lugar de cuando se llama al método.

Lo hubiera sugerido en un comentario, pero desafortunadamente aún no tengo la reputación para él.