In Python, method names starting from __ are not private. __ means to let Python do name mangling. The result of name mangling is _A__priv. You should not overwrite using this method. If you want a subclass to overwrite a method, you can only use _, not __

After thinking about this question for a while, here’s my understanding:

class A(object):
    def __init__(self):
        self.__priv()  # _A__priv()
        self.pub()

    def __priv(self):
        print("private A")

    def pub(self):
        print("public A")


class B(A):
    def __init__(self):
        self.__priv()    # 调用_B__priv()对比
        super(B, self).__init__()  # 在这里显式调用父类的`__init__()`方法

    def __priv(self):
        print("private B")

    def pub(self):
        print("public B")


if __name__ == '__main__':
    b = B()

Call __init__()方法时，从子类B本身中查找pub()方法，显然是存在的，因此会调用B类自身的pub()方法；然而在调用__priv()方法时，由于Python对私有成员进行了名称改编，你实际调用的是_A__priv()方法，而B类中并没有这个方法，有的只有_B__priv(),因此调用父类A中的_A__priv() on the instance of the subclass, resulting in this result. This is my personal understanding, please correct me if I am wrong, thank you.

As for the problem itself, @Xavier and @Christoph have already explained it in detail

If you still don’t understand, you can try this:

Original code:

class A:
    def __init__(self):
        self.__priv() # 等等改成 self._A__priv()
        self.public()
    def __priv(self): # 等等改成 def _A__priv(self):
        print('private of A')
    def public(self):
        print('public of A')
        
class B(A):
    def __priv(self): # 等等改成 self._B__priv(self):
        print('private of B')
    def public(self):
        print('public of B')
        
b = B()

Do it manually name mangling:

class A:
    def __init__(self):
        self._A__priv()
        self.public()
    def _A__priv(self):
        print('private of A')
    def public(self):
        print('public of A')
        
class B(A):
    def _B__priv(self):
        print('private of B')
    def public(self):
        print('public of B')
        
b = B()

B 在這裡繼承了 A include:

• __init__

• _A__priv

• public

And B defined it by itself:

• _B__priv

• public (此處覆寫了 A 的 public (here overridden

  of A)

dir(b)So at the end you will see

• __init__ (從 A

  (inherited from A)

• _A__priv (從 A

  (inherited from A)

• _B__priv

  (your own definition)

• public

  (your own definition)

__init__ 被呼叫時, 會調用 _A__priv, 而 BFinally, when

does have this method in it

a = A()
a._A__priv() # 防都防不住

single Bottom line

Ian Bicking has a passage that says this (Ian Bicking is a Python master, I saw this passage in Luciano Ramalho’s Fluent Python):

Never use two base lines in front of it. This is infuriatingly selfish, and if you don't want to cause a name conflict (Note 2), you can reshape the name explicitly (eg: _MyThing_blahblah). Essentially this is the same as using The double bottom line is the same thing, but it is public, while the double bottom line is a private behavior._priv

would be a better choice.const Note 1: Attributes starting with a single underscore will not have any special properties. It is just a symbolic method that relies on the consensus of Python programmers. Just like some languages ​​​​will use

constants should be named in uppercase letters

Questions I answered: Python-QA