2022年 11月 4日

Python:类的继承，调用父类的属性和方法基础详解

知乎主页：

知乎主页https://www.zhihu.com/people/shuang-shou-cha-dai-53

备注：这里省略了关于继承含义的解释，直接上代码了，更直观点

  • 子类：Son类
  • 父类：Father类

以下案例均表示Son类继承父类的一些属性和初始化参数构造等。

5个模块：

（1）：直接调用父类属性方法

（2）：重写父类属性方法

（3）：强制调用父类私有属性方法

（4）：调用父类的__init__方法

（5）：继承父类初始化过程中的参数

（1）调用父类属性方法

代码1.1：

  1. class Father():
  2.     def __init__(self):
  3.         self.a='aaa'  
  4.     def action(self):
  5.         print('调用父类的方法')
  6.  
  7. class Son(Father):
  8.     pass
  9.  
  10. son=Son()     # 子类Son 继承父类Father的所有属性和方法
  11. son.action()  # 调用父类方法
  12. son.a         # 调用父类属性

输出结果：

（2）重写父类属性方法

注意：在上面的例子中，子类Son没有属性和action的方法，所以会从父类调用，那我们再来看看，子类Son有自身的属性和方法的结果是怎样的？

上述代码修改为：

  1. class Father():
  2.     def __init__(self):
  3.         self.a='aaa'
  4.     
  5.     def action(self):
  6.         print('调用父类的方法')
  7.  
  8. class Son(Father):
  9.     def __init__(self):
  10.         self.a='bbb'
  11.     def action(self):
  12.         print('子类重写父类的方法')
  13.  
  14. son=Son()     # 子类Son继承父类Father的所有属性和方法
  15. son.action()  # 子类Son调用自身的action方法而不是父类的action方法
  16. son.a

输出结果：

这里，子类Son已经重写了父类Father的action的方法，并且子类Son也有初始化，因此，子类会调用自身的action方法和属性。总结：如果子类没有重写父类的方法，当调用该方法的时候，会调用父类的方法，当子类重写了父类的方法，默认是调用自身的方法。

另外，如果子类Son重写了父类Father的方法，如果想调用父类的action方法，可以利用super()

代码2.1：

  1. #如果在重新父类方法后，调用父类的方法
  2. class Father():
  3.     def action(self):
  4.         print('调用父类的方法')
  5.  
  6. class Son(Father):
  7.     def action(self):
  8.         super().action()
  9. son=Son()
  10. son.action()

输出结果：

（3）强制调用父类私有属性方法

如果父类的方法是私有方法,如 def __action(self)  这样的话再去调用就提示没有这个方法,其实编译器是把这个方法的名字改成了 _Father__action(),如果强制调用,可以这样:

代码3.1

  1. class Father():
  2.     def __action(self):  # 父类的私有方法
  3.         print('调用父类的方法')
  4.  
  5. class Son(Father):
  6.     def action(self):
  7.         super()._Father__action()
  8. son=Son()
  9. son.action()

输出结果：

（4）调用父类的__init__方法

如果自己也定义了 __init__ 方法,那么父类的属性是不能直接调用的，比如下面的代码就会报错

代码4.1：

  1. class Father():
  2.     def __init__(self):
  3.         self.a=a
  4.  
  5. class Son(Father):
  6.     def __init__(self):
  7.         pass
  8.     
  9. son=Son()
  10. print(son.a)

结果报错：

修改方法：可以在 子类的 __init__中调用一下父类的 __init__ 方法,这样就可以调用了

  1. class Father():
  2.     def __init__(self):
  3.         self.a='aaa'
  4.  
  5. class Son(Father):
  6.     def __init__(self):
  7.         super().__init__()
  8.         #也可以用 Father.__init__(self)  这里面的self一定要加上
  9. son=Son()
  10. print(son.a)

输出结果：

（5）继承父类初始化过程中的参数

代码5.1：

  1. class Father():
  2.     def __init__(self):
  3.         self.a=1
  4.         self.b=2
  5.  
  6. class Son(Father):
  7.     def __init__(self):
  8.         super().__init__()
  9.         #也可以用 Father.__init__(self)  这里面的self一定要加上
  10.     def add(self):
  11.         return self.a+self.b
  12. son=Son()
  13. print(son.add())

 输出结果： 

上述代码中，父类在初始化过程中，直接对a，b分别赋值1,2。子类利用super().__init__()继承了父类的初始化参数a和b，所以子类调用自身的add函数（add函数返回a和b的和）会返回结果值。

再看一下，如果不对父类初始化直接赋值，并且子类在调用父类初始化过程中，增加额外自身需要的初始化参数值。

说明：三个参数a,b,c，其中a,b来自父类初始化参数，c表示子类初始化参数，但又分为两种情况：

1）：参数c为初始化默认参数，如下面的5.1代码中Son(1,2)，参数1,2分别表示a,b的值，默认为c=10，即等于：Son(1,2,10)，表明初始化传参过程中c可以不写

2）：显式地将初始化参数c修改为其他值，如下面的5.2代码中Son(1,2,1)，参数值1,2,1分别表示a,b,c的值，即显式地将c=1传入

具体代码如5.1 ， 5.2所示，对比查看：

代码5.1：

  1. class Father():
  2.     def __init__(self,a,b):
  3.         self.a = a
  4.         self.b = b
  5.     def dev(self):
  6.         return self.a - self.b
  7.  
  8.  #调用父类初始化参数a,b并增加额外参数c
  9. class Son(Father):
  10.     def __init__(self,a,b,c=10):  # 固定值： 例如默认c=10，也可以显示地将c赋值
  11.         Father.__init__(self,a,b)  
  12.         self.c = c
  13.     def add(self):
  14.         return self.a+self.b
  15.     def compare(self):
  16.         if self.c > (self.a+self.b):
  17.             return True
  18.         else:
  19.             return False
  20.         
  21. son=Son(1,2)         # 由于c在初始化过程中默认为10，所以c可以不用显示表达出来
  22. print(son.dev())     # 调用父类dev函数
  23. print(son.add())     # 子类自身add函数
  24. print(son.compare()) # 子类自身compare函数

返回结果：

如果将上述5.1代码中，修改c为其他参数值（非默认值），改成显式地将c值传入

代码5.2：

  1. class Father():
  2.     def __init__(self,a,b):
  3.         self.a = a
  4.         self.b = b
  5.     def dev(self):
  6.         return self.a - self.b
  7.  
  8.  #调用父类初始化参数a,b并增加额外参数c
  9. class Son(Father):
  10.     def __init__(self,a,b,c=10):  # 固定值： 例如默认c=10，也可以显式地将c赋值
  11.         Father.__init__(self,a,b)  
  12.         self.c = c
  13.     def add(self):
  14.         return self.a+self.b
  15.     def compare(self):
  16.         if self.c > (self.a+self.b):
  17.             return True
  18.         else:
  19.             return False
  20.         
  21. son=Son(1,2,1)     #  显式地将c=1传入子类初始化函数
  22. print(son.dev())     # 调用父类dev函数
  23. print(son.add())     # 子类自身add函数
  24. print(son.compare()) # 子类自身compare函数

输出结果：

附：

（1）Python类的实例化，封装，继承，私有变量和私有方法

（2）Python-实例方法静态方法类方法对比总结

以上基本涵盖了Python类的继承，调用父类的属性和方法基础内容，可以自己动手写些案例，加深理解。

知乎主页：

知乎主页https://www.zhihu.com/people/shuang-shou-cha-dai-53