Herencia Python - cómo deshabilitar una función

Question

En C ++ puede deshabilitar una función en la clase del padre declarándola como privada en la clase del niño. ¿Cómo se puede hacer esto en Python? ES DECIR. ¿Cómo puedo ocultar la función de los padres de la interfaz pública del niño?

Answer 1

Realmente no hay ningún " privado " " atributos o métodos en Python. Una cosa que puede hacer es simplemente anular el método que no desea en la subclase y generar una excepción:

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

El método de

kurosch para resolver el problema no es del todo correcto, porque aún puede usar b.foo sin obtener un AttributeError . Si no invoca la función, no se produce ningún error. Aquí hay dos formas en las que puedo pensar para hacer esto:

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

La barra utiliza el " ajuste " Patrón para restringir el acceso al objeto envuelto. Martelli tiene una buena charla sobre este tema. Baz usa la propiedad incorporada para implementar el protocolo descriptor para el atributo a anular.

Answer 3

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 genera un AttributeError en la propiedad en lugar de cuando se llama al método.

Lo habría sugerido en un comentario, pero lamentablemente todavía no tengo la reputación de hacerlo.

Answer 4

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

class Y(object):
    some_function = None

Esto puede llevar a que se generen algunas excepciones desagradables y difíciles de encontrar, así que puedes 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 5

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

Anule los métodos y haga que cada uno de los métodos anulados llame a su método disabledmethods (). Así:

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 6

Eso podría ser incluso más simple.

@property
def private(self):
    raise AttributeError

class A:
    def __init__(self):
        pass
    def hello(self):
        print("Hello World")

class B(A):
    hello = private # that short, really
    def hi(self):
        A.hello(self)

obj = A()
obj.hello()
obj = B()
obj.hi() # works
obj.hello() # raises AttributeError