Python - 继承

什么是 Python 中的继承？

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

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

当新类与现有类具有 'IS A' 关系时，继承就会出现。例如，Car IS 车辆，Bus IS 车辆，Bike IS 车辆。此处，Vehicle 是父类，而 car、bus 和 bike 是子类。

创建 Parent Class

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

语法

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

class ParentClassName:
	 	{class body}

创建 Child 类

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

语法

以下是子类的语法 -

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()	

在运行上述代码时，它将打印以下结果 -

Python - 多重继承

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

语法

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

例

Python 的标准库有一个内置的 divmod（） 函数，该函数返回一个包含两项的元组。第一个数字是两个参数的除法，第二个是两个操作数的 mod 值。

此示例尝试模拟 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（） 方法以返回 division 和 mod 值。

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

输出

方法解析顺序 （MRO）

术语 method resolution order 与 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()	

当我们执行上述代码时，它会产生以下结果——

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() 	

在执行上述程序时，您将获得以下输出 -

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()

在运行上述程序时，它将给出以下结果 -

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 qikepu!!")
obj.showMessage() 	

在执行时，上述程序将给出以下结果 -