__init__中的python名称修改似乎不一致

Question

I'm trying to use a subclass that enhances instead of overriding the base class. I'm using the super method to call the base class. I find that I need to use the name mangling feature in __init__ (but only in init?) to make the code work. So for the heck of it I made the this print example. Since I didn't use name mangling I expected it to call subclass twice when I did the init, instead it calls the base class

It seems that __init__ sometimes sees the base class and sometimes sees the subclass. I'm sure it's just an incomplete understanding on my part, but was do I need name mangling for the real code, when in the print example it calls the base and subclass just fine?

the code

class base:
    def __init__(self):
        self.print()

    def print(self):
        print("base")

class subclass(base):
    def __init__(self):
        super(subclass, self).__init__()
        self.print()

    def print(self):
        super(subclass, self).print()
        print("subclass")

x = base()
x.print()
print("--")
y = subclass()
y.print()

the output - why doesn't y = subclass() print subclass instead of base since I didn't use name mangling?

> ./y.py 
base
base
-- 
base
subclass
base
subclass
base  
subclass

broken code when I don't use name mangling, works when I use self.__set and __set = set (the commented code). It gets the following error when I don't use __set :

File "./x.py", line 5, in __init__
   self.set(arg)
TypeError: set() missing 1 required positional argument: 'arg2'

the code:

class base:
    def __init__(self, arg):
        self.set(arg)
        # self.__set(arg)

    # __set = set

    def set(self, arg):
        self.arg = arg

    def print(self):
        print("base",self.arg)

class subclass(base):
    def __init__(self, arg1, arg2):
        super(subclass, self).__init__(arg1)
        self.set(arg1, arg2)

    def set(self, arg1, arg2):
        super(subclass, self).set(arg1)
        self.arg2 = arg2

    def print(self):
        super(subclass, self).print()
        print("subclass", self.arg2, self.arg)

x = base(1)

x.print()
x.set(11)
x.print()

y = subclass(2,3)

y.print()
y.set(4,5)
y.print()

======= update =======

I rewrote the code to look like this:

class base:
    def __init__(self):
        print("base init")
        self.print()

    def print(self):
        print("base print")

class subclass(base):
    def __init__(self):
        print("sc init")
        super(subclass, self).__init__()
        print("sc after super")
        self.print()

    def print(self):
        print("subclass print start")
        super(subclass, self).print()
        print("subclass print")

y = subclass()
print("--")
y.print()

when I run I get this output:

sc init
base init
subclass print start <<<< why is the subclass print called here
base print
subclass print
sc after super
subclass print start
base print
subclass print
--
subclass print start
base print
subclass print

why does the self.print in the base init call the subclass print when I'm initing the subclass? I was expecting that to call the base print. it does call the base print when I call it outside of the init.

Answer 1

Your subclass print explicitly calls the superclass one. So every time subclass.print is called, both "base" and "subclass" will be printed. This happens three times, because you call the print method three times: in subclass.__init__ , in base.__init__ (which is called by subclass.__init__ ), and in subclass.print (which calls the superclass version).

In your "set" example, subclass.__init__ calls base.__init__ , which tries to call self.set with just one argument. But since you are instantiating subclass , self.set is subclass.set , which takes two arguments.

It's unclear what you're trying to achieve with these examples. Your subclass doesn't really need to call base.__init__ , because all that would do is call base.set , and you're already calling that from subclass.set . So even if you succeeded with all your calls, it would result in some methods getting called multiple times, just like with the print example.

My impression is that you're getting a bit carried away and trying to have every method call its superclass version. That's not always a good idea. If you write a subclass, and it calls a superclass method, you need to make sure that the subclass still provides an interface that's compatible with what the superclass expects. If it doesn't, you may need to not call the superclass method and instead have the subclass incorporate its functionality "inline" (although this may be more risky if other classes out in the world have made assumptions about how the base class works). The upshot is that you always need to think about what methods call which others; you can't just call every superclass method everywhere and expect that to work.