Python - 繼承

上一頁
下一頁

什麼是 Python 中的繼承？

繼承是像 Python 這樣的面向物件程式語言最重要的特性之一。它用於將一個類的屬性和行為繼承到另一個類。繼承另一個類的類稱為子類，被繼承的類稱為基類或父類。

如果你必須設計一個新類，而它的大部分屬性已經在現有類中定義得很好了，那麼為什麼要重新定義它們呢？繼承允許重用現有類的功能，如果需要，可以擴充套件它們來設計新類。

當新類與現有類具有“IS A”關係時，就會出現繼承。例如，汽車是車輛，公共汽車是車輛，腳踏車也是車輛。這裡，車輛是父類，而汽車、公共汽車和腳踏車是子類。

inheritance

建立父類

屬性和方法被繼承的類稱為父類。它的定義方式與其他類一樣，即使用 class 關鍵字。

語法

建立父類的語法如下所示：

class ParentClassName:
   {class body}

建立子類

從基類繼承的類與它們的父類的宣告方式類似，但是，我們需要在括號內提供父類的名稱。

語法

以下是子類的語法：

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

繼承的型別

在 Python 中，繼承可以分為五類：

  • 單繼承
  • 多繼承
  • 多層繼承
  • 層次繼承
  • 混合繼承
types of inheritance

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!!
列印頁面
上一頁
下一頁
廣告
© . All rights reserved.