Python说文解字_父类的继承

1. 第一个问题：

　　我们知道类是可以继承其他类的，在继承的过程中我们不光可以继承父类的方法，还可继承父类的属性，另外还可以在父类的基础上添加自己的东西。

 

2. 第二个问题：

　　我们继承父类属性和方法的时候无需再把父类的属性和方法再写一般。通常用的方法是：父类名.方法/属性，另外还有一种方式就是super().的方法。但其实这两种方式是有一些不同的。

　　首先举例第一种方式：父类名.方法/属性。

　　代码：

class BaseClass:
    num_Base_calls = 0
    def call_me(self):
        print("Calling method on BaseClass")
        self.num_Base_calls += 1

class LeftSubclass(BaseClass):
    num_left_calls = 0
    def call_me(self):
        BaseClass.call_me(self)
        print("Calling method on LeftSubclass")
        self.num_left_calls += 1

class RightSubclass(BaseClass):
    num_Right_calls = 0
    def call_me(self):
        BaseClass.call_me(self)
        print("Calling method on RightSubclass")
        self.num_Right_calls += 1

class Subclass(LeftSubclass,RightSubclass):
    num_Sub_calls = 0
    def call_me(self):
        LeftSubclass.call_me(self)
        RightSubclass.call_me(self)
        print("Calling method on Subclass")
        self.num_Sub_calls += 1

s = Subclass()
s.call_me()

# Calling method on BaseClass
# Calling method on LeftSubclass
# Calling method on BaseClass
# Calling method on RightSubclass
# Calling method on Subclass

print(s.num_Sub_calls)
print(s.num_left_calls)
print(s.num_Right_calls)
print(s.num_Base_calls)

# 1
# 1
# 1
# 2

　　说明1：有这么一个基类叫做Baseclass，继承给Leftclass和Rightclass，然后Leftclass和Rightclass分别继承给Subclass。就是这么一个简单的关系。

　　说明2：问题是，在最后的Subclass被执行的时候，我们发现最基础的基类中的Call_me方法被执行了2次？

　　说明3：关于多继承需要记住的是，我们只想调用类层级的下一个方法，而不是“父类”方法。实际上，下一个方法可能不属于该类的父类或者更早的祖先。

　　说明4. 说的更明白一点就是这种模式是如图所示：

　　subclass -- 寻找--Leftclass--寻找--Baseclass：第一遍：打印Baseclass和Leftclass

　　subclass -- 寻找 -- Rightclass -- 寻找 -- Baseclass：第二遍：打印：Baseclass和Rightclass

　　subclass -- 自己-- 打印 subclass

　　说明5：其实我们在实际的过程中，继承到最后，我们只想寻找一遍父类的父类（最初的祖先类），用这种方式是不行的。因此我们引入了super()这个函数来阻断只查找一次。

　　

　　其次：我们用super()的方法去只查找一遍祖先类，代码如下：

class BaseClass:
    num_Base_calls = 0
    def call_me(self):
        print("Calling method on BaseClass")
        self.num_Base_calls += 1

class LeftSubclass(BaseClass):
    num_left_calls = 0
    def call_me(self):
        super().call_me()
        print("Calling method on LeftSubclass")
        self.num_left_calls += 1

class RightSubclass(BaseClass):
    num_Right_calls = 0
    def call_me(self):
        super().call_me()
        print("Calling method on RightSubclass")
        self.num_Right_calls += 1

class Subclass(LeftSubclass,RightSubclass):
    num_Sub_calls = 0
    def call_me(self):
        super().call_me()
        print("Calling method on Subclass")
        self.num_Sub_calls += 1

s = Subclass()
s.call_me()

# Calling method on BaseClass
# Calling method on RightSubclass
# Calling method on LeftSubclass
# Calling method on Subclass

print(s.num_Sub_calls)
print(s.num_left_calls)
print(s.num_Right_calls)
print(s.num_Base_calls)

# 1
# 1
# 1
# 1

　　说明1：我们在每一个子类的每一个类中加入了super()这种方式就解决了这个问题。

　　说明2：这样查找顺序就变成了如下：

　　subclass -- 查找 -- leftclass 和 rightclass -- 包含 -- Baseclass：打印：basecalss，right subclass，leftclass，subclass

 

3. 总结：

　　使用第一种方法就是用二分通路的方式，走一遍，循环回来再走一遍。

　　使用第二种方法就是用包含的方式，像剥洋葱一样，一层一层的剥开，相似的不再保留。