Python - 继承

什么是Python中的继承？

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

如果你必须设计一个新类，而大多数属性在现有类中已经定义得很清楚，那为什么还要重新定义它们呢？继承允许复用现有类的能力，并在需要时扩展以设计新类。

继承是在新类与现有类之间存在"IS A"关系时出现的。例如，汽车是车辆，公交车是车辆，自行车也是车辆。这里，车辆是父级，而汽车、公交和自行车是子类。

创建父类

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

语法

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

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（）函数。我们定义两个类：除法和模数类，然后有一个继承它们的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类继承了除法类和模类。因此，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 - 层级继承

这种继承包含多个从单一基类继承而来的派生类。这类似于组织内部的层级结构。

示例

以下示例说明了层级继承。这里，我们定义了两个子类的管理者类。

# 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!!