四-1、面向對象程式設計

面向對象程式設計（Object-Oriented Programming，OOP）是一種程式設計範式，将資料和操作資料的方法組合成一個對象，并通過封裝、繼承和多态等機制來進行抽象和子產品化。Python是一門支援面向對象程式設計的語言，其提供了類（Class）和對象（Object）等基本元素，可以用于建立各種複雜的資料結構和程式。

下面是Python面向對象程式設計的基本概念和示例：

類的定義

在Python中，類通過class關鍵字進行定義。類定義中通常包含屬性（Attribute）和方法（Method）兩部分。

# 定義一個Person類
class Person:
    # 定義屬性
    name = ""
    age = 0
    
    # 定義方法
    def say_hello(self):
        print("Hello, my name is", self.name)
           

在上面的例子中，我們定義了一個Person類，其中包含了name和age兩個屬性和say_hello方法。屬性通常用于存儲資料，方法則用于執行某些操作。

在Python中，我們可以使用class關鍵字來定義一個類，然後在類中定義屬性和方法。下面是一個簡單的例子，示範了如何定義一個類：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def bark(self):
        print("汪汪！")
        
    def introduce(self):
        print(f"我是一隻名叫{self.name}的小狗，今年{self.age}歲了。")
           

這裡我們定義了一個叫做Dog的類，這個類有兩個屬性，name和age，還有兩個方法，bark和introduce。其中__init__方法是一個特殊的方法，用于在建立對象時初始化屬性值。另外兩個方法可以在任何時候調用。

下面我們可以使用這個類建立一隻叫做小黑的狗：

my_dog = Dog("小黑", 3)
           

這樣我們就建立了一個名為my_dog的對象，它的名字是小黑，年齡是3歲。我們可以使用這個對象來調用類的方法：

my_dog.bark()      # 輸出“汪汪！”
my_dog.introduce() # 輸出“我是一隻名叫小黑的小狗，今年3歲了。”
           

類的定義可以有很多變化，比如可以定義繼承，可以定義靜态方法等等。但是核心的思想都是一樣的：定義一個資料類型，并在其中封裝資料和方法，用于實作特定的功能。

對象的建立和使用

在Python中，可以通過類來建立對象，并通路對象的屬性和方法。

# 建立一個Person對象
person = Person()

# 設定對象的屬性
person.name = "Tom"
person.age = 18

# 調用對象的方法
person.say_hello()
           

在上面的例子中，我們建立了一個Person對象，并通過對象的屬性和方法來操作對象。具體來說，我們設定了對象的name和age屬性，并調用了對象的say_hello方法來列印出一個問候語。

以下是一些建立和使用對象的例子：

1. 建立一個汽車對象，設定它的屬性（顔色、品牌、價格）并調用它的方法（加速、刹車、鳴笛）：

class Car:
    def __init__(self, color, brand, price):
        self.color = color
        self.brand = brand
        self.price = price
        self.speed = 0
        
    def accelerate(self):
        self.speed += 10
        print(f"The {self.color} {self.brand} car accelerates to {self.speed} km/h.")
        
    def brake(self):
        self.speed -= 10
        print(f"The {self.color} {self.brand} car slows down to {self.speed} km/h.")
        
    def horn(self):
        print("Beep! Beep!")
        
my_car = Car("red", "Toyota", 20000)
my_car.accelerate()  # 輸出：The red Toyota car accelerates to 10 km/h.
my_car.brake()       # 輸出：The red Toyota car slows down to 0 km/h.
my_car.horn()        # 輸出：Beep! Beep!
           

1. 建立一個人員對象，設定它的屬性（姓名、性别、年齡）并調用它的方法（打招呼、介紹自己）：

class Person:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age
        
    def greet(self):
        print(f"Hi, my name is {self.name}!")
        
    def introduce(self):
        print(f"I am a {self.gender}, and I am {self.age} years old.")
        
myself = Person("Alice", "female", 25)
myself.greet()       # 輸出：Hi, my name is Alice!
myself.introduce()   # 輸出：I am a female, and I am 25 years old.
           

1. 建立一個圓形對象，設定它的屬性（半徑）并調用它的方法（計算面積、周長）：

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius
        
    def area(self):
        return math.pi * self.radius ** 2
        
    def perimeter(self):
        return 2 * math.pi * self.radius
        
my_circle = Circle(5)
print(f"The area of the circle is {my_circle.area()}.")         # 輸出：The area of the circle is 78.53981633974483.
print(f"The perimeter of the circle is {my_circle.perimeter()}.") # 輸出：The perimeter of the circle is 31.41592653589793.
           

繼承和多态

在Python中，可以使用繼承來擴充已有的類，并使用多态來實作不同類之間的統一調用接口。

# 定義一個Student類，繼承自Person類
class Student(Person):
    # 重寫say_hello方法
    def say_hello(self):
        print("Hello, my name is", self.name, ", and I'm a student.")

# 建立一個Student對象
student = Student()

# 設定對象的屬性
student.name = "Lucy"
student.age = 20

# 調用對象的方法
student.say_hello()
           

在上面的例子中，我們定義了一個Student類，繼承自Person類，并重寫了say_hello方法。然後，我們建立了一個Student對象，并使用該對象的屬性和方法來操作對象。具體來說，我們設定了對象的name和age屬性，并調用了對象的say_hello方法來列印出一個問候語。由于Student類重寫了say_hello方法，是以輸出的問候語與Person類的不同。

以下是一些示例：

1. 繼承

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def make_sound(self):
        print("The dog barks.")

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def make_sound(self):
        print("The cat meows.")

dog = Dog("Buddy")
cat = Cat("Fluffy")
dog.make_sound()  # 輸出 "The dog barks."
cat.make_sound()  # 輸出 "The cat meows."
           

在這個示例中，我們定義了一個 Animal 類，它有一個 make_sound 方法，但它并沒有實作具體的行為。然後，我們定義了 Dog 類和 Cat 類，它們都繼承了 Animal 類，并分别實作了自己的 make_sound 方法。這樣，我們就可以用這些類來建立具體的對象，如 dog 和 cat。

1. 多态

class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Square(Shape):
    def __init__(self, length):
        self.length = length
    
    def area(self):
        return self.length ** 2

shapes = [Circle(5), Square(4), Circle(3)]

for shape in shapes:
    print(shape.area())
           

在這個示例中，我們定義了一個 Shape 類和兩個子類 Circle 和 Square。它們都實作了自己的 area 方法，但是由于它們都是 Shape 類的子類，是以可以被視為同一類型。我們将這些對象放在一個清單中，并周遊這個清單，依次調用它們的 area 方法。這樣，我們就可以根據需要動态地切換不同的對象，而不需要修改代碼。這就是多态的好處。

總的來說，Python面向對象程式設計的基本元素包括類、對象、屬性和方法等，可以用于建立複雜的資料結構和程式。在實際應用中，面向對象程式設計通常被用于封裝和複用代碼，提高程式的可維護性和可擴充性。