Python Vererbung - wie eine bestimmte Funktion deaktivieren

Question

In C ++ können Sie eine Funktion in den Eltern-Klasse deaktivieren, indem sie als privat in der Kinderklasse deklarieren. Wie kann dies in Python getan werden? I.E. Wie kann ich mich verstecken Eltern Funktion von Kindern öffentliche Schnittstelle?

Answer 1

Es gibt wirklich nicht wahr „private“ Attribute oder Methoden in Python. Eine Sache, die Sie tun können, ist einfach die Methode überschreiben Sie nicht in der Unterklasse möchten, und heben eine Ausnahme:

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

Kurosch Methode, das Problem zu lösen, ist nicht ganz richtig, weil Sie noch b.foo, ohne sich einen AttributeError verwenden können. Wenn Sie nicht die Funktion aufrufen, tritt kein Fehler auf. Es gibt zwei Möglichkeiten, die ich denken kann, dies zu tun:

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 verwendet die „wrap“ Muster Zugriff auf das Objekt eingewickelt zu beschränken. Martelli hat ein gutes Gespräch mit dieser beschäftigen. Baz verwendet die Eigenschaft integrierten das Descriptor-Protokoll zu implementieren für das Attribut außer Kraft zu setzen.

Answer 3

Eine Variation der Antwort von 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

Dies wirft eine AttributeError auf dem Grundstück statt, wenn die Methode aufgerufen wird.

Ich habe es in einem Kommentar vorgeschlagen würde, aber leider haben nicht den Ruf für ihn noch nicht.

Answer 4

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

class Y(object):
    some_function = None

Dies kann zu einig bösen und hart führt Ausnahmen obwohl geworfen zu finden, so dass Sie könnte dies versuchen:

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

Dies ist der sauberste Weg, ich weiß, es zu tun.

die Methoden außer Kraft setzen und jede der überschriebenen Methoden haben Ihre disabledmethods () -Methode aufrufen. Wie folgt aus:

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

Das könnte noch einfacher.

@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