多类继承

Question

I'm studying about OOP method. but now I'm stuck with this. The model I want is class X and class Y. it has many calculations and different method. The class X and Y need input to in the class. Then bring the output from class X.cal1 and Y.cal2. To summarize in class Z. but class Z need input for calculation in class themselves. The code is an example to represent my calculation flow. Not an actual my code. it looks like every class need input. But it can't make one big class, then have many functions in the class. it needs to be class themselves. Then join all class in the new class. Now my code doesn't work.

class X():
    def __init__(self,x):
        super(X, self).__init__()
        self.x = x

    def cal1(self):
        return self.x*2

class Y():
    def __init__(self,y):
        super(Y, self).__init__()
        self.y = y

    def cal2(self):
        return self.y/2

class Z(X,Y):
    def __init__(self,Z):
        super(Z, self).__init__()
        self.Z = Z
        self.xx = X.cal1()
        self.yy = Y.cal2()

    def cal3(self):
        return self.z+self.xx+self.yy

if__name__=='__main__':
   R1 = X(30)
   R2 = Y(20)
   R3 = Z(R1,R2,50)

Answer 1

I don't like the approach, but you can use:

class Z(X, Y):
    def __init__(self, x, y, z):
        super().__init__(x)
        super(X, self).__init__(y)
        self.z = z

And remove the super() calls in X and Y .

Another approach is using kwargs or not having arguments in __init__ so that you can keep the same init signature in all classes. Once you do that, you may use super() and the Method Resolution Order (MRO) to call the init functions. The call stack would look like this:

• Z(x=.., y=.., z=..) calls Z.__init__
• Z.__init__ gets the z kwarg and calls super().__init__(**kwargs) which is X.__init__
• X.__init__ gets the x kwarg and calls super().__init__(**kwargs) which is Y.__init__
• Y.__init__ gets the y kwarg and calls super().__init__() which is object.__init__

Note: super() without arguments only works in Python 3.

The last approach I can think of is not (!) using super and just calling X.__init__(self, x) and Y.__init__(self, y) inside Z directly.