Python - 继承

什么是 Python 中的继承？

继承是像 Python 这样的面向对象编程语言最重要的特性之一。它用于将一个类的属性和行为继承到另一个类。继承另一个类的类称为子类，被继承的类称为基类或父类。

如果你必须设计一个新类，而它的大部分属性已经在现有类中定义得很好了，那么为什么要重新定义它们呢？继承允许重用现有类的功能，如果需要，可以扩展它们来设计新类。

当新类与现有类具有“IS A”关系时，就会出现继承。例如，汽车是车辆，公共汽车是车辆，自行车也是车辆。这里，车辆是父类，而汽车、公共汽车和自行车是子类。

创建父类

属性和方法被继承的类称为父类。它的定义方式与其他类一样，即使用 class 关键字。

语法

创建父类的语法如下所示：

class ParentClassName:
   {class body}

创建子类

从基类继承的类与它们的父类的声明方式类似，但是，我们需要在括号内提供父类的名称。

语法

以下是子类的语法：

class SubClassName (ParentClass1[, ParentClass2, ...]):
   {sub class body}

继承的类型

在 Python 中，继承可以分为五类：

• 单继承
• 多继承
• 多层继承
• 层次继承
• 混合继承

Python - 单继承

这是最简单的继承形式，其中子类只从一个父类继承属性和方法。

示例

下面的示例展示了 Python 中的单继承概念：

# parent class
class Parent: 
   def parentMethod(self):
      print ("Calling parent method")

# child class
class Child(Parent): 
   def childMethod(self):
      print ("Calling child method")

# instance of child
c = Child()  
# calling method of child class
c.childMethod() 
# calling method of parent class
c.parentMethod() 

运行上述代码后，将打印以下结果：

Calling child method
Calling parent method

Python - 多继承

Python 中的多继承允许你基于多个父类构建一个类。因此，子类继承了所有父类的属性和方法。子类可以覆盖从任何父类继承的方法。

语法

class parent1:
   #statements
   
class parent2:
   #statements
   
class child(parent1, parent2):
   #statements

示例

Python 的标准库有一个内置的 divmod() 函数，它返回一个包含两项的元组。第一个数字是两个参数的除法结果，第二个是两个操作数的模值。

此示例尝试模拟 divmod() 函数。我们定义了两个类 division 和 modulus，然后有一个 div_mod 类继承它们。

class division:
   def __init__(self, a,b):
      self.n=a
      self.d=b
   def divide(self):
      return self.n/self.d
class modulus:
   def __init__(self, a,b):
      self.n=a
      self.d=b
   def mod_divide(self):
      return self.n%self.d
      
class div_mod(division,modulus):
   def __init__(self, a,b):
      self.n=a
      self.d=b
   def div_and_mod(self):
      divval=division.divide(self)
      modval=modulus.mod_divide(self)
      return (divval, modval)

子类有一个新的方法 div_and_mod()，它内部调用其继承类的 divide() 和 mod_divide() 方法来返回除法和模值。

x=div_mod(10,3)
print ("division:",x.divide())
print ("mod_division:",x.mod_divide())
print ("divmod:",x.div_and_mod())

输出

division: 3.3333333333333335
mod_division: 1
divmod: (3.3333333333333335, 1)

方法解析顺序 (MRO)

术语方法解析顺序与 Python 中的多继承有关。在 Python 中，继承可能跨越多个级别。假设 A 是 B 的父类，B 是 C 的父类。C 类可以覆盖继承的方法，或者它的对象可以调用在其父类中定义的方法。那么，Python 如何找到要调用的适当方法呢？

每个 Python 都有一个 mro() 方法，它返回 Python 用于解析要调用的方法的层次顺序。解析顺序是从继承顺序的底部到顶部。

在我们之前的示例中，div_mod 类继承了 division 和 modulus 类。因此，mro 方法返回的顺序如下：

[<class '__main__.div_mod'>, <class '__main__.division'>, <class '__main__.modulus'>, <class 'object'>]

Python - 多层继承

在多层继承中，一个类派生自另一个派生类。存在多层继承关系。我们可以将其想象为祖父母-父母-子女的关系。

示例

在下面的例子中，我们将演示多层继承的工作方式。

# parent class
class Universe: 
   def universeMethod(self):
      print ("I am in the Universe")

# child class
class Earth(Universe): 
   def earthMethod(self):
      print ("I am on Earth")
      
# another child class
class India(Earth): 
   def indianMethod(self):
      print ("I am in India")      

# creating instance 
person = India()  
# method calls
person.universeMethod() 
person.earthMethod() 
person.indianMethod() 

执行以上代码后，将产生以下结果：

I am in the Universe
I am on Earth
I am in India

Python - 层次继承

这种类型的继承包含多个派生类，它们继承自单个基类。这类似于组织内部的层次结构。

示例

下面的例子说明了层次继承。在这里，我们定义了Manager类的两个子类。

# parent class
class Manager: 
   def managerMethod(self):
      print ("I am the Manager")

# child class
class Employee1(Manager): 
   def employee1Method(self):
      print ("I am Employee one")
      
# second child class
class Employee2(Manager): 
   def employee2Method(self):
      print ("I am Employee two")      

# creating instances 
emp1 = Employee1()  
emp2 = Employee2()
# method calls
emp1.managerMethod() 
emp1.employee1Method()
emp2.managerMethod() 
emp2.employee2Method()  

执行上述程序后，您将获得以下输出：

I am the Manager
I am Employee one
I am the Manager
I am Employee two

Python - 混合继承

两种或多种继承类型的组合称为混合继承。例如，它可能是单继承和多继承的混合。

示例

在这个例子中，我们结合了单继承和多继承，形成了类的混合继承。

# parent class
class CEO: 
   def ceoMethod(self):
      print ("I am the CEO")
      
class Manager(CEO): 
   def managerMethod(self):
      print ("I am the Manager")

class Employee1(Manager): 
   def employee1Method(self):
      print ("I am Employee one")
      
class Employee2(Manager, CEO): 
   def employee2Method(self):
      print ("I am Employee two")      

# creating instances 
emp = Employee2()
# method calls
emp.managerMethod() 
emp.ceoMethod()
emp.employee2Method()

运行上述程序后，将给出以下结果：

I am the Manager
I am the CEO
I am Employee two

super() 函数

在 Python 中，super() 函数允许您从子类中访问父类的方法和属性。

示例

在下面的例子中，我们创建一个父类，并使用 super() 函数从子类访问其构造函数。

# parent class
class ParentDemo:
   def __init__(self, msg):
      self.message = msg

   def showMessage(self):
      print(self.message)

# child class
class ChildDemo(ParentDemo):
   def __init__(self, msg):
      # use of super function
      super().__init__(msg)  

# creating instance
obj = ChildDemo("Welcome to Tutorialspoint!!")
obj.showMessage()  

执行后，上述程序将给出以下结果：

Welcome to Tutorialspoint!!