如何使用具有相同名称且相互依赖的方法处理python继承？

Question

I try to maintain a class. The basic program struct I hoped shows below.

class FooFather():
    def __init__(self):
        self.meta=0
    def add(self):
        self.meta+=1
    def act(self):
        self.add()
class FooChild(FooFather):
    def __init__(self):
        FooFather.__init__(self)
    def add(self):
        self.meta+=2
    def act(self):
        FooFather.act(self)

The result shows below.

foo=FooChild()
foo.act()
print(foo.meta)
=>2     //not 1 I want to have

I understand the mechanism. The child class overwrites the methods of father (both add and act). How can I overwrite a method meanwhile I can keep the relation between original methods?

Answer 1

self refers to the current instance. So when FooFather.act() calls self.add() it is referring to the add method of the current instance, which is a FooChild() instance. Therefore FooChild.add(self) is called.

If you want FooFather.act() to call FooFather.add() instead, you need to have FooFather.act() do so explicitly: ie, FooFather.add(self)

Answer 2

Not sure what you want really based on your question, but I'm guessing something like this, where act calls the superclass' add (using python 2.7 syntax):

class FooFather(object):
    def __init__(self):
        self.meta=0
    def add(self):
        self.meta+=1
    def act(self):
        self.add()
class FooChild(FooFather):
    def __init__(self):
        super(FooChild, self).__init__()
    def add(self):
        self.meta+=2
    def act(self):
        super(FooChild, self).add()

Answer 3

You can use pseudo privates, see https://docs.python.org/2/tutorial/classes.html#private-variables-and-class-local-references

class FooFather:
    def __init__(self):
        self.meta = 0

    def __add(self):
        print self.meta, '-->',
        self.meta += 1
        print self.meta

    def act(self):
        self.__add()

class FooChild(FooFather):
    def __add(self):
        print self.meta, '==>',
        self.meta += 2
        print self.meta

    def act2(self):
        FooFather.act(self)

    def act3(self):
        self.__add()



>>> c = FooChild()
>>> c.act()
0 --> 1
>>> c.act2()
1 --> 2
>>> c.act3()
2 ==> 4