方法分類:
  ┌───────────────┐
  │  實例方法     │ ← 操作實例屬性，第一個參數(shù)self
  ├───────────────┤
  │  類方法       │ ← 操作類屬性，@classmethod裝飾，第一個參數(shù)cls
  ├───────────────┤
  │  靜態(tài)方法     │ ← 不操作類或?qū)嵗龑傩裕珸staticmethod裝飾
  ├───────────────┤
  │  抽象方法     │ ← 必須由子類實現(xiàn)，@abstractmethod裝飾
  ├───────────────┤
  │  魔術(shù)方法     │ ← 雙下劃線開頭結(jié)尾，如__init__
  └───────────────┘

class MyClass:
    class_attr = "類屬性"
    
    def __init__(self, value):
        self.instance_attr = value  # 實例屬性
    
    def instance_method(self):
        return f"實例屬性: {self.instance_attr}, 類屬性: {self.class_attr}"

obj = MyClass("實例值")
print(obj.instance_method())  # 實例屬性: 實例值, 類屬性: 類屬性

class Pizza:
    base_price = 10  # 基礎(chǔ)價格
    
    def __init__(self, toppings):
        self.toppings = toppings
    
    @classmethod
    def margherita(cls):
        return cls(["番茄", "芝士"])  # 創(chuàng)建特定類型的披薩
    
    @classmethod
    def pepperoni(cls):
        return cls(["番茄", "芝士", "意大利辣香腸"])
    
    @classmethod
    def update_base_price(cls, new_price):
        cls.base_price = new_price  # 修改類屬性

# 使用類方法創(chuàng)建對象
margherita = Pizza.margherita()
pepperoni = Pizza.pepperoni()

print(margherita.toppings)  # ['番茄', '芝士']
print(pepperoni.toppings)   # ['番茄', '芝士', '意大利辣香腸']

# 修改類屬性
Pizza.update_base_price(12)
print(Pizza.base_price)  # 12

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def circle_area(radius):
        return 3.14159 * radius ** 2

# 使用靜態(tài)方法
print(MathUtils.add(5, 3))         # 8
print(MathUtils.circle_area(2))    # 12.56636

# 也可以通過實例調(diào)用
utils = MathUtils()
print(utils.add(10, 20))          # 30

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass
    
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "汪汪!"
    
    def move(self):
        return "跑動"

# animal = Animal()  # 報錯，不能實例化抽象類
dog = Dog()
print(dog.make_sound())  # 汪汪!
print(dog.move())        # 跑動

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        """向量加法"""
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
    
    def __len__(self):
        """返回向量長度(歐幾里得距離)"""
        return int((self.x**2 + self.y**2)**0.5)

v1 = Vector(3, 4)
v2 = Vector(5, 6)
v3 = v1 + v2  # 調(diào)用__add__

print(v3)      # Vector(8, 10) (調(diào)用__str__)
print(len(v1)) # 5 (調(diào)用__len__)

from abc import ABC, abstractmethod
from datetime import datetime

class Product(ABC):
    """商品抽象基類"""
    tax_rate = 0.1  # 類屬性: 稅率
    
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity
        self.__id = self.__generate_id()  # 私有屬性
    
    def __generate_id(self):
        """私有方法: 生成商品ID"""
        timestamp = int(datetime.now().timestamp())
        return f"PROD-{timestamp}"
    
    @property
    def id(self):
        """只讀屬性: 商品ID"""
        return self.__id
    
    @abstractmethod
    def display_info(self):
        """抽象方法: 顯示商品信息"""
        pass
    
    @classmethod
    def update_tax_rate(cls, new_rate):
        """類方法: 更新稅率"""
        cls.tax_rate = new_rate
    
    @staticmethod
    def calculate_discount(price, discount):
        """靜態(tài)方法: 計算折扣價"""
        return price * (1 - discount)
    
    def sell(self, quantity):
        """實例方法: 銷售商品"""
        if quantity <= self.quantity:
            self.quantity -= quantity
            total = quantity * self.price * (1 + self.tax_rate)
            return f"已售出 {quantity} 件 {self.name}, 總價: {total:.2f}"
        return "庫存不足"

class Book(Product):
    """具體商品類: 圖書"""
    def __init__(self, name, price, quantity, author):
        super().__init__(name, price, quantity)
        self.author = author
    
    def display_info(self):
        """實現(xiàn)抽象方法"""
        return (f"圖書: {self.name}\n"
                f"作者: {self.author}\n"
                f"價格: ￥{self.price:.2f}\n"
                f"庫存: {self.quantity}件\n"
                f"含稅價: ￥{self.price * (1 + self.tax_rate):.2f}")

class Electronics(Product):
    """具體商品類: 電子產(chǎn)品"""
    def __init__(self, name, price, quantity, warranty):
        super().__init__(name, price, quantity)
        self.warranty = warranty  # 保修期(月)
    
    def display_info(self):
        """實現(xiàn)抽象方法"""
        return (f"電子產(chǎn)品: {self.name}\n"
                f"保修: {self.warranty}個月\n"
                f"價格: ￥{self.price:.2f}\n"
                f"庫存: {self.quantity}件\n"
                f"含稅價: ￥{self.price * (1 + self.tax_rate):.2f}")

# 使用示例
if __name__ == "__main__":
    # 修改稅率(類方法)
    Product.update_tax_rate(0.15)
    
    # 創(chuàng)建商品
    book = Book("Python編程", 59.99, 100, "John Doe")
    phone = Electronics("智能手機", 2999.99, 50, 24)
    
    # 顯示商品信息(實例方法)
    print(book.display_info())
    print("\n" + phone.display_info())
    
    # 銷售商品(實例方法)
    print("\n" + book.sell(2))
    print(phone.sell(1))
    
    # 計算折扣(靜態(tài)方法)
    discounted_price = Product.calculate_discount(phone.price, 0.2)
    print(f"\n手機8折價: ￥{discounted_price:.2f}")
    
    # 訪問私有屬性(通過property)
    print(f"\n圖書ID: {book.id}")
    # print(book.__id)  # 報錯，無法直接訪問私有屬性