有什么办法可以限制孩子 class 继承其父母的某些方法吗？

Question

class Liquid(object):
    def foo(self):
        pass

    def bar(self):
        pass

class Water(Liquid):

Say, I have the two classes above, Water inherits from Liquid . Is there any way I can restrict Water from inheriting one of the parent's methods, say bar() ?

Answer 1

Sort of. But don't do it.

class Liquid(object):
    def foo(self):
        pass

    def bar(self):
        pass

class Water(Liquid):
    def __getattribute__(self, name):
        if name == 'bar':
            raise AttributeError("'Water' object has no attribute 'bar'")

l = Liquid()
l.bar()
w = Water()
w.bar()

Answer 2

You can override the method to be a no-op, but you can't remove it. Doing so would violate one of the core principles of object-oriented design, namely that any object that inherits from some parent should be able to be used anywhere the parent is used. This is known as the Liskov Substitution Principle.

Answer 3

You can, as the other answers, say, break one of the inherited methods.

The alternative is to refactor out the "optional" methods, and inherit from a baseclass that doesn't have them:

class BaseLiquid(object):
    def foo(self):
        pass

class Barised(object):
    def bar(self):
        pass

class Liquid(BaseLiquid, Barised): pass

class Water(BaseLiquid):
    def drip(self):
        pass

Answer 4

This is probably not a good idea, but you could always use metaclasses to implement private attributes:

def private_attrs(name, bases, attrs):
    def get_base_attrs(base):
        result = {}

        for deeper_base in base.mro()[1:]:
            result.update( get_base_attrs(deeper_base) )

        priv = []
        if "__private__" in base.__dict__:
            priv = base.__private__

        for attr in base.__dict__:
            if attr not in priv:
                result.update( {attr: base.__dict__[attr]} )

        return result


    final_attrs = {}
    for base in bases:
        final_attrs.update( get_base_attrs(base) )

    final_attrs.update(attrs)

    return type(name, (), final_attrs)


class Liquid(object):
    __metaclass__ = private_attrs
    __private__ = ['bar']
    def foo(self):
        pass

    def bar(self):
        pass

class Water(Liquid):
    __metaclass__ = private_attrs

print Water.foo
print Water.bar

Output is:

<unbound method Water.foo>
Traceback (most recent call last):
  File "testing-inheritance.py", line 41, in <module>
    print Water.bar
AttributeError: type object 'Water' has no attribute 'bar'

EDIT: This will mess up isinstance() because it doesn't modify bases of the class.

Answer 5

http://docs.python.org/release/2.5.2/ref/slots.html

I suspect you can do this, by using the slots attr.

It might be possible implementing a getattr method and throwing the appropriate exception if bar is called.

However, I agree, you don't want to do this in practice, since its a sign of bad design.