Python的繼承（Inheritance）是面向對象編程（OOP）中的一個核心概念，它允許一個類（子類）繼承另一個類（父類）的屬性和方法。通過繼承，可以實現代碼的重用和擴展，並能夠覆蓋和擴展父類的功能。

壹、基本繼承

在Python中，子類可以繼承父類的屬性和方法。子類通過class SubClass(ParentClass)的語法來繼承父類。

• 基本繼承

# 父類
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound")

# 子類，繼承自 Animal
class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks")

# 創建子類對象
dog = Dog("Buddy")
dog.speak()  # 輸出: Buddy barks

在這個範例中Dog類繼承了Animal類。Dog類覆蓋了Animal的speak方法，因此當我們調用speak()時，會執行子類的方法。

貳、super()函數

super()函數用來調用父類的方法或屬性，特別是在子類覆蓋了父類的方法時，它允許我們在子類中使用父類的實現。

• 使用super()調用父類方法

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 調用父類的初始化方法
        self.breed = breed

    def speak(self):
        super().speak()  # 調用父類的 speak 方法
        print(f"{self.name} barks")

dog = Dog("Buddy", "Golden Retriever")
dog.speak()
# 輸出:
# Buddy makes a sound
# Buddy barks

這裡的super().__init__(name)調用了父類Animal的__init__方法，這樣Dog類仍然可以利用父類的初始化邏輯。同樣，super().speak()調用了父類的speak方法。

參、方法覆蓋（Method Overriding）

在子類中，可以覆蓋父類的方法。當子類的對象調用這個方法時，將執行子類中的實現，而不是父類中的實現。

• 覆蓋方法

class Animal:
    def speak(self):
        print("Animal makes a sound")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

cat = Cat()
cat.speak()  # 輸出: Cat meows

在這個例子中，Cat類覆蓋了父類Animal的speak方法，因此當我們調用cat.speak()時，會執行子類的實現。

肆、多重繼承（Multiple Inheritance）

Python支持多重繼承，這意味著一個類可以同時繼承多個父類。多重繼承使用逗號分隔父類。

• 多重繼承

class Flyer:
    def fly(self):
        print("Can fly")

class Swimmer:
    def swim(self):
        print("Can swim")

class Duck(Flyer, Swimmer):
    pass

duck = Duck()
duck.fly()   # 輸出: Can fly
duck.swim()  # 輸出: Can swim

在這個範例中，Duck類同時繼承了Flyer和Swimmer類，因此它能夠訪問兩個父類的方法。

• 方法解析順序（MRO）
  多重繼承時，Python 使用方法解析順序（MRO）來決定當方法在多個父類中出現時應該調用哪個父類的方法。可以通過ClassName.mro()來查看方法解析順序。

print(Duck.mro())
# 輸出:
# [<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>]

伍、父類與子類的關係

子類繼承父類後，可以：

繼承父類的屬性和方法。
自己擁有新的屬性和方法。
覆蓋父類的方法。

• 父類方法和子類新屬性

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print(f"{self.brand} is starting")

class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand)
        self.model = model

    def start(self):
        super().start()  # 調用父類的 start 方法
        print(f"{self.brand} {self.model} is ready to go")

car = Car("Toyota", "Corolla")
car.start()
# 輸出:
# Toyota is starting
# Toyota Corolla is ready to go

在這裡，Car類擁有新的屬性model，並覆蓋了start方法，但仍然可以使用super()調用父類的start方法。

陸、抽象類（Abstract Class）

在某些情況下，我們不希望父類的某些方法有具體實現，這時可以使用抽象類。抽象類是不能實例化的類，僅作為其他類的基礎。它可以定義抽象方法，要求子類必須實現這些方法。

• 使用abc模塊實現抽象類

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass  # 抽象方法，子類必須實現

class Dog(Animal):
    def speak(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 輸出: Dog barks

在這裡，Animal是抽象類，speak是抽象方法，子類Dog必須實現speak方法，否則會拋出錯誤。

柒、繼承的優勢

**代碼重用 **：子類可以直接使用父類的屬性和方法，避免重複編寫代碼。
** 結構化設計 **：繼承允許將不同的功能分層設計，子類專注於特定功能。
** 靈活性與可擴展性 **：可以在子類中覆蓋或擴展父類的功能，使得系統具有更高的靈活性。