1. 面向對象編程的核心概念

面向對象編程（OOP）是一種編程范式，它將數據和操作數據的方法封裝在一起，形成對象。Python作為一門多范式編程語言，對OOP提供了強大的支持。

1.1 類與對象的關系

類是對象的模板或藍圖，定義了對象的屬性和行為。對象是類的實例，是具體的數據實體。這種關系類似于建筑圖紙與實際建筑物的關系。

class Car:def __init__(self, brand, model):self.brand = brandself.model = modeldef start(self):return f"{self.brand} {self.model} is starting"# 創建對象實例
my_car = Car("Toyota", "Camry")
print(my_car.start())  # Toyota Camry is starting

1.2 封裝（Encapsulation）

封裝是將數據和方法綁定在一起，并限制對對象內部狀態的直接訪問。Python通過命名約定來實現封裝：

• 公共屬性：直接訪問
• 受保護屬性：以單下劃線開頭（_attribute）
• 私有屬性：以雙下劃線開頭（__attribute）

class BankAccount:def __init__(self, balance):self._balance = balance  # 受保護屬性self.__account_number = "123456789"  # 私有屬性def deposit(self, amount):if amount > 0:self._balance += amountdef get_balance(self):return self._balancedef _internal_method(self):  # 受保護方法return "Internal processing"

2. 繼承與多態

2.1 繼承機制

繼承允許一個類獲得另一個類的屬性和方法，促進代碼重用并建立類之間的層次關系。

class Vehicle:def __init__(self, brand, year):self.brand = brandself.year = yeardef start(self):return "Vehicle is starting"def stop(self):return "Vehicle is stopping"class ElectricCar(Vehicle):def __init__(self, brand, year, battery_capacity):super().__init__(brand, year)  # 調用父類構造函數self.battery_capacity = battery_capacitydef charge(self):return f"Charging {self.brand} with {self.battery_capacity}kWh battery"def start(self):  # 方法重寫return f"Electric {self.brand} is silently starting"

2.2 多重繼承

Python支持多重繼承，但需要注意方法解析順序（MRO）。

class Flyable:def fly(self):return "Flying in the sky"class Swimmable:def swim(self):return "Swimming in water"class Duck(Flyable, Swimmable):def __init__(self, name):self.name = namedef quack(self):return f"{self.name} says quack!"# 查看方法解析順序
print(Duck.__mro__)

2.3 多態性

多態性允許不同類的對象對同一消息做出不同的響應，通過統一的接口處理不同類型的對象。

class Shape:def area(self):raise NotImplementedError("Subclass must implement area method")class Rectangle(Shape):def __init__(self, width, height):self.width = widthself.height = heightdef area(self):return self.width * self.heightclass Circle(Shape):def __init__(self, radius):self.radius = radiusdef area(self):return 3.14159 * self.radius ** 2# 多態性的體現
def print_area(shape):print(f"Area: {shape.area()}")shapes = [Rectangle(5, 3), Circle(4)]
for shape in shapes:print_area(shape)  # 同一接口，不同實現

3. 特殊方法與運算符重載

Python提供了豐富的特殊方法（魔術方法），允許類定義對象的行為。

class Vector:def __init__(self, x, y):self.x = xself.y = ydef __str__(self):return f"Vector({self.x}, {self.y})"def __repr__(self):return f"Vector({self.x!r}, {self.y!r})"def __add__(self, other):return Vector(self.x + other.x, self.y + other.y)def __eq__(self, other):return self.x == other.x and self.y == other.ydef __len__(self):return int((self.x ** 2 + self.y ** 2) ** 0.5)v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Vector(4, 6)
print(v1 == v2)  # False

4. 抽象類與接口

4.1 抽象基類

使用abc模塊創建抽象基類，強制子類實現特定方法。

from abc import ABC, abstractmethodclass Animal(ABC):@abstractmethoddef make_sound(self):pass@abstractmethoddef move(self):passdef sleep(self):  # 具體方法return "Animal is sleeping"class Dog(Animal):def make_sound(self):return "Woof!"def move(self):return "Dog is running"# Animal()  # 會報錯，不能實例化抽象類
dog = Dog()
print(dog.make_sound())  # Woof!

5. 組合與聚合

組合是一種"has-a"關系，表示整體與部分的強關聯。

class Engine:def __init__(self, horsepower):self.horsepower = horsepowerdef start(self):return f"Engine with {self.horsepower}HP is starting"class Car:def __init__(self, brand, engine):self.brand = brandself.engine = engine  # 組合關系def start(self):return f"{self.brand}: {self.engine.start()}"engine = Engine(200)
car = Car("BMW", engine)
print(car.start())  # BMW: Engine with 200HP is starting

6. 屬性管理

6.1 使用property裝飾器

class Temperature:def __init__(self, celsius=0):self._celsius = celsius@propertydef celsius(self):return self._celsius@celsius.setterdef celsius(self, value):if value < -273.15:raise ValueError("Temperature below absolute zero is not possible")self._celsius = value@propertydef fahrenheit(self):return (self._celsius * 9/5) + 32@fahrenheit.setterdef fahrenheit(self, value):self.celsius = (value - 32) * 5/9temp = Temperature(25)
print(temp.fahrenheit)  # 77.0
temp.fahrenheit = 86
print(temp.celsius)     # 30.0

6.2 描述符協議

描述符提供了更高級的屬性控制機制。

class Validator:def __init__(self, min_value=0, max_value=100):self.min_value = min_valueself.max_value = max_valuedef __set_name__(self, owner, name):self.name = namedef __get__(self, instance, owner):if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):if not (self.min_value <= value <= self.max_value):raise ValueError(f"{self.name} must be between {self.min_value} and {self.max_value}")instance.__dict__[self.name] = valueclass Student:grade = Validator(0, 100)def __init__(self, name, grade):self.name = nameself.grade = grade  # 使用描述符驗證

7. 元類與類裝飾器

7.1 元類

元類是創建類的類，控制類的創建過程。

class SingletonMeta(type):_instances = {}def __call__(cls, *args, **kwargs):if cls not in cls._instances:cls._instances[cls] = super().__call__(*args, **kwargs)return cls._instances[cls]class Database(metaclass=SingletonMeta):def __init__(self):self.connection = "Connected to database"db1 = Database()
db2 = Database()
print(db1 is db2)  # True，單例模式

7.2 類裝飾器

類裝飾器提供了修改類行為的簡潔方式。

def add_logging(cls):original_init = cls.__init__def new_init(self, *args, **kwargs):print(f"Creating instance of {cls.__name__}")original_init(self, *args, **kwargs)cls.__init__ = new_initreturn cls@add_logging
class Product:def __init__(self, name, price):self.name = nameself.price = priceproduct = Product("Laptop", 999)  # 輸出: Creating instance of Product

8. 設計模式實踐

8.1 觀察者模式

class Subject:def __init__(self):self._observers = []self._state = Nonedef attach(self, observer):self._observers.append(observer)def detach(self, observer):self._observers.remove(observer)def notify(self):for observer in self._observers:observer.update(self._state)def set_state(self, state):self._state = stateself.notify()class Observer:def update(self, state):print(f"Observer received update: {state}")subject = Subject()
observer1 = Observer()
observer2 = Observer()subject.attach(observer1)
subject.attach(observer2)
subject.set_state("New State")  # 通知所有觀察者