Python 物件導向程式設計核心概念

物件導向程式設計是提升程式碼重用性和組織性的重要途徑，Python 作為一個支援物件導向的語言，提供類別、物件和繼承等機制。類別作為物件的藍圖，定義了物件的結構和行為。透過類別，可以建立多個具有相同屬性和方法的物件例項。繼承則允許子類別繼承父類別的特性，並擴充套件或修改其功能，減少程式碼冗餘並促程式式碼的模組化設計。理解這些核心概念對於有效運用 Python 物件導向程式設計至關重要。

物件導向程式設計：類別、物件與繼承

物件導向程式設計（Object-Oriented Programming, OOP）是一種程式設計正規化，強調使用物件來表示現實世界中的實體。Python 是一種支援物件導向程式設計的語言，其基本概念包括類別（Class）、物件（Object）與繼承（Inheritance）。

類別與物件

類別是物件的藍圖或範本，定義了物件的屬性和方法。物件是類別的例項，具有類別中定義的屬性和方法。

class Demo:
    def __init__(self, A, B, C):
        self.a = A
        self.b = B
        self.c = C

    def display(self):
        print(self.a, self.b, self.c)

B1 = Demo(100, 200, 300)
print('基底類別內容')
B1.display()

程式碼解析：

class Demo: 定義了一個名為 Demo 的類別。
def __init__(self, A, B, C): 是類別的建構函式，用於初始化物件的屬性。
self.a = A、self.b = B 和 self.c = C 將傳入的引數指定給物件的屬性。
def display(self): 定義了一個名為 display 的方法，用於列印物件的屬性。
B1 = Demo(100, 200, 300) 建立了一個 Demo 類別的物件 B1，並傳入引數 100、200 和 300。

繼承

繼承是一種機制，允許一個類別繼承另一個類別的屬性和方法。子類別（Subclass）可以繼承父類別（Superclass）的屬性和方法，並可以新增或覆寫父類別的方法。

class NewDemo(Demo):
    def __init__(self, A, B, C, D):
        self.d = D
        super().__init__(A, B, C)

    def display(self):
        print(self.a, self.b, self.c, self.d)

D1 = NewDemo(10, 20, 30, 40)
print('衍生類別內容')
D1.display()

程式碼解析：

class NewDemo(Demo): 定義了一個名為 NewDemo 的子類別，繼承自 Demo 類別。
def __init__(self, A, B, C, D): 是子類別的建構函式，呼叫了父類別的建構函式 super().__init__(A, B, C) 來初始化父類別的屬性。
self.d = D 初始化了子類別特有的屬性 d。
def display(self): 覆寫了父類別的 display 方法，列印了子類別的所有屬性。

方法覆寫

方法覆寫是指子類別中定義了一個與父類別中相同名稱和簽名的方法，從而覆寫了父類別的方法。

class A:
    def display(self):
        print('我在父類別')

class B(A):
    def display(self):
        print('我在子類別')
        super().display()

D1 = B()
D1.display()

程式碼解析：

class B(A): 定義了一個子類別 B，繼承自父類別 A。
def display(self): 在子類別 B 中覆寫了父類別 A 的 display 方法。
super().display() 呼叫了父類別的 display 方法。

多重繼承中的方法覆寫

在多重繼承中，如果多個父類別具有相同名稱的方法，子類別需要小心處理以避免混淆。

class A:
    def Display(self):
        print("我在A")

class B(A):
    def Display(self):
        print("我在B")
        super().Display()

class C(A):
    def Display(self):
        print("我在C")
        super().Display()

class D(B, C):
    def Display(self):
        print("我在D")
        super().Display()

Ob = D()
Ob.Display()

程式碼解析：

使用 super() 可以正確地呼叫多重繼承中的父類別方法，避免重複呼叫。

複數運算的小型專案

這個小型專案展示瞭如何使用物件導向程式設計來實作複數的運算，包括加法、減法、乘法、相等性比較和大小比較。

class Complex:
    def __init__(self, real=0, imag=0):
        self.real = real
        self.imag = imag

    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)

    def __mul__(self, other):
        real_part = self.real * other.real - self.imag * other.imag
        imag_part = self.real * other.imag + self.imag * other.real
        return Complex(real_part, imag_part)

    def __eq__(self, other):
        return self.real == other.real and self.imag == other.imag

    def __ge__(self, other):
        magnitude_self = (self.real ** 2 + self.imag ** 2) ** 0.5
        magnitude_other = (other.real ** 2 + other.imag ** 2) ** 0.5
        return magnitude_self >= magnitude_other

    def __le__(self, other):
        magnitude_self = (self.real ** 2 + self.imag ** 2) ** 0.5
        magnitude_other = (other.real ** 2 + other.imag ** 2) ** 0.5
        return magnitude_self <= magnitude_other

    def __str__(self):
        return f"{self.real} + {self.imag}i"

# 示例用法
C1 = Complex(3, 2)
C2 = Complex(1, 7)

print("C1:", C1)
print("C2:", C2)
print("C1 + C2:", C1 + C2)
print("C1 - C2:", C1 - C2)
print("C1 * C2:", C1 * C2)
print("C1 == C2:", C1 == C2)
print("C1 >= C2:", C1 >= C2)
print("C1 <= C2:", C1 <= C2)

程式碼解析：

定義了一個名為 Complex 的類別來表示複數，具有實部和虛部屬性。
使用特殊方法（如 __add__、__sub__、__mul__）來實作複數的加法、減法和乘法運算。
使用特殊方法（如 __eq__、__ge__、__le__）來比較複數的相等性和大小。
使用 __str__ 方法來提供複數的字串表示。

Python 中的複數類別實作與運算元多載

在 Python 中，物件導向程式設計（Object-Oriented Programming, OOP）是一種重要的程式設計正規化。類別（Class）是 OOP 的基本建構模組，用於定義物件的屬性和方法。本文將探討如何使用 Python 實作一個複數類別，並對運算元進行多載，以實作複數的基本運算。

複數類別的定義

首先，我們需要定義一個名為 Complex 的類別，用於表示複數。複數由實部和虛部組成，因此我們的類別需要包含這兩個屬性。

class Complex(object):
    def __init__(self, real, imag=0.0):
        self.real = real
        self.imag = imag

內容解密：

__init__ 方法是類別的建構子，用於初始化物件。在這裡，我們設定了 real 和 imag 兩個屬性，分別代表複數的實部和虛部。
imag=0.0 表示虛部預設為 0，這樣我們就可以用單一引數建立純實數的複數。

列印複數

為了方便檢視複數，我們需要一個方法來列印它。

def print_Complex_Number(self):
    print(f'({self.real}, {self.imag}i)')

內容解密：

print_Complex_Number 方法用於列印複數，格式為 (實部, 虛部i)。
使用 f-string 可以方便地將變數嵌入字串中。

運算元的多載

Python 允許我們對運算元進行多載，以實作自定義的運算邏輯。以下是加法、減法、乘法、相等性比較、大於和小於等運算元的多載實作。

def __add__(self, other):
    return Complex(self.real + other.real, self.imag + other.imag)

def __sub__(self, other):
    return Complex(self.real - other.real, self.imag - other.imag)

def __mul__(self, other):
    real_part = self.real * other.real - self.imag * other.imag
    imag_part = self.real * other.imag + self.imag * other.real
    return Complex(real_part, imag_part)

def __eq__(self, other):
    return self.real == other.real and self.imag == other.imag

def __le__(self, other):
    return self.real <= other.real and self.imag <= other.imag

def __ge__(self, other):
    return self.real >= other.real and self.imag >= other.imag

內容解密：

__add__、__sub__ 和 __mul__ 方法分別對應加法、減法和乘法運算元。這些方法傳回新的 Complex 物件，表示運算結果。
複數的乘法遵循特定的數學規則：(a + bi) * (c + di) = (ac - bd) + (ad + bc)i。
__eq__ 方法用於比較兩個複數是否相等，條件是實部和虛部都相等。
__le__ 和 __ge__ 方法分別用於比較兩個複數的大小，條件是實部和虛部都滿足對應的比較關係。

使用複數類別

現在，我們可以建立 Complex 物件並進行各種運算。

C1 = Complex(2, 1)
print('第一個複數：')
C1.print_Complex_Number()

C2 = Complex(5, 6)
print('第二個複數：')
C2.print_Complex_Number()

print('兩個複數的和：')
C3 = C1 + C2
C3.print_Complex_Number()

print('兩個複數的差：')
C4 = C1 - C2
C4.print_Complex_Number()

print('兩個複數的積：')
C5 = C1 * C2
C5.print_Complex_Number()

print('比較兩個複數是否相等：')
print(C1 == C2)

print('檢查 C1 是否大於 C2：')
print(C1 >= C2)

print('檢查 C1 是否小於 C2：')
print(C1 <= C2)

內容解密：

我們建立了兩個 Complex 物件 C1 和 C2，並進行了加法、減法、乘法、相等性比較、大於和小於等運算。
每個運算結果都透過對應的方法進行了輸出。

物件導向程式設計：類別、物件與繼承

物件導向程式設計（Object-Oriented Programming, OOP）是一種程式設計正規化，它使用「物件」來設計應用程式和電腦程式。Python是一種支援物件導向程式設計的語言，它提供了類別（Class）、物件（Object）以及繼承（Inheritance）等概念。

類別與物件

在Python中，類別是一種定義物件結構和行為的範本。物件是類別的例項，它們具有類別中定義的屬性和方法。

類別的定義

類別的定義使用class關鍵字，後面跟著類別的名稱和一個冒號。類別的內容縮排在class陳述式下面。

class Coordinate(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def getX(self):
        return self.x

    def getY(self):
        return self.y

物件的建立

要建立一個物件，需要呼叫類別的建構函式（Constructor），也就是__init__方法。

p1 = Coordinate(1, 2)
p2 = Coordinate(3, 4)

繼承

繼承是一種機制，允許一個類別繼承另一個類別的屬性和方法。被繼承的類別稱為父類別（Parent Class）或基礎類別（Base Class），繼承的類別稱為子類別（Child Class）或衍生類別（Derived Class）。

繼承的型別

Python支援多種繼承型別，包括單一繼承（Single Inheritance）、多重繼承（Multiple Inheritance）和多層繼承（Multilevel Inheritance）。

單一繼承：一個子類別只繼承一個父類別。
多重繼承：一個子類別可以繼承多個父類別。
多層繼承：一個子類別繼承一個父類別，而這個父類別又繼承另一個父類別。

繼承的例子

class Shape:
    def __init__(self, color):
        self.color = color

class Rectangle(Shape):
    def __init__(self, color, length, breadth):
        super().__init__(color)
        self.length = length
        self.breadth = breadth

    def calc_area(self):
        return self.length * self.breadth

class Triangle(Shape):
    def __init__(self, color, base, height):
        super().__init__(color)
        self.base = base
        self.height = height

    def calc_area(self):
        return 0.5 * self.base * self.height

rect = Rectangle("red", 4, 5)
print(rect.calc_area())

tri = Triangle("blue", 3, 6)
print(tri.calc_area())

方法覆寫

方法覆寫（Method Overriding）是指子類別提供了一個與父類別相同名稱的方法，但具有不同的實作。

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calc_area(self):
        return 3.14 * self.radius ** 2

class Cylinder(Circle):
    def __init__(self, radius, height):
        super().__init__(radius)
        self.height = height

    def calc_area(self):
        return 2 * 3.14 * self.radius * self.height

cyl = Cylinder(4, 5)
print(cyl.calc_area())

特殊方法

Python中的特殊方法（Special Methods）是以雙下劃線開頭和結尾的方法，例如__init__、__del__等。這些方法在特定的情況下被呼叫，例如物件建立或銷毀時。

練習題

寫一個程式，建立一個名為Demo的類別。定義兩個方法Get_String()和Print_String()。從使用者接受字串並以大寫列印字串。
寫一個程式，建立一個名為Circle的類別。執行以下操作：
- 定義屬性radius。
- 定義帶有一個引數的建構函式，包含半徑。
- 定義名為get_radius()的方法，傳回圓的半徑。
- 定義名為calc_area()的方法，傳回圓的面積。
寫一個程式，建立一個名為Point的類別。執行以下操作：
- 初始化點的X和Y座標。
- 定義方法‘Display()’列印座標。
- 定義方法Translate(X, Y)將點在X方向上移動X單位，在Y方向上移動Y單位。

練習題解答

# 練習題1
class Demo:
    def Get_String(self):
        self.str = input("請輸入字串：")

    def Print_String(self):
        print(self.str.upper())

demo = Demo()
demo.Get_String()
demo.Print_String()

# 練習題2
class Circle:
    def __init__(self, radius):
        self.radius = radius

    def get_radius(self):
        return self.radius

    def calc_area(self):
        return 3.14 * self.radius ** 2

circle = Circle(5)
print("半徑：", circle.get_radius())
print("面積：", circle.calc_area())

# 練習題3
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def Display(self):
        print("座標：({}, {})".format(self.x, self.y))

    def Translate(self, x, y):
        self.x += x
        self.y += y

point = Point(1, 2)
point.Display()
point.Translate(3, 4)
point.Display()

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。