Python 面向对象编程（进阶篇）

class Celsius:
    def __init__(self, temperature=0):
        self._temperature = temperature  # 私有属性（约定，非强制）
 
    @property
    def temperature(self):
        print("获取温度...")
        return self._temperature
 
    @temperature.setter
    def temperature(self, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度！")
        print("设置温度...")
        self._temperature = value
 
    @temperature.deleter
    def temperature(self):
        print("删除温度属性...")
        del self._temperature
 
# 使用示例
c = Celsius(25)
print(c.temperature)  # 调用 getter
c.temperature = 30    # 调用 setter
del c.temperature     # 调用 deleter

class TemperatureDescriptor:
    def __get__(self, instance, owner):
        print(f"从 {instance} 中获取属性，类是 {owner}")
        return instance.__dict__[self.name]  # 避免递归，直接操作__dict__
 
    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度！")
        instance.__dict__[self.name] = value
 
    def __set_name__(self, owner, name):  # Python 3.6+ 新增，自动绑定属性名
        self.name = name
 
class Celsius:
    temperature = TemperatureDescriptor()  # 描述符实例作为类属性
 
    def __init__(self, temperature=0):
        self.temperature = temperature  # 触发 __set__
 
# 使用示例
c = Celsius(25)
print(c.temperature)  # 触发 __get__
c.temperature = 30    # 触发 __set__

class Person:
    def __init__(self, name):
        self.name = name
 
    def say_hello(self):  # 实例方法
        print(f"你好，我是 {self.name}")
 
p = Person("Alice")
p.say_hello()  # 必须通过实例调用

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
 
    @classmethod
    def from_string(cls, date_str):  # 类方法，cls绑定到Date类
        year, month, day = map(int, date_str.split('-'))
        return cls(year, month, day)  # 创建Date实例
 
# 使用
d = Date.from_string("2023-10-01")
print(d.year, d.month, d.day)

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b
 
# 调用方式：类或实例均可
print(MathUtils.add(3, 5))
mu = MathUtils()
print(mu.add(4, 6))

class A:
    def show(self):
        print("A")
 
class B(A):
    def show(self):
        print("B")
 
class C(A):
    def show(self):
        print("C")
 
class D(B, C):
    pass
 
# 查看MRO
print(D.mro())  # 输出: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
 
d = D()
d.show()  # 输出 B（因为B在MRO中先于C）

class A:
    def show(self):
        print("A")
 
class B(A):
    def show(self):
        print("B")
        super().show()  # 调用父类（A）的方法
 
class C(A):
    def show(self):
        print("C")
        super().show()  # 调用父类（A）的方法
 
class D(B, C):
    def show(self):
        print("D")
        super().show()  # 调用MRO中的下一个类（B）
 
d = D()
d.show() 
# 输出：
# D
# B
# C
# A

from abc import ABC, abstractmethod
 
class Shape(ABC):  # 继承ABC，指定元类为ABCMeta
    @abstractmethod
    def area(self):
        """计算面积的抽象方法，子类必须实现"""
        pass
 
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
 
    def area(self):  # 必须实现area方法
        return 3.14 * self.radius **2
 
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
 
    def area(self):
        return self.width * self.height
 
# 错误示例：不实现抽象方法
class InvalidShape(Shape):
    pass
 
# s = Shape()  # 报错：Cannot instantiate abstract class Shape with abstract method area
# ishape = InvalidShape()  # 报错：Cannot instantiate abstract class InvalidShape with abstract method area
 
# 正确使用
c = Circle(5)
print(c.area())  # 78.5

@Shape.register
class Square:  # 未继承Shape
    def __init__(self, side):
        self.side = side
 
    def area(self):
        return self.side **2
 
s = Square(4)
print(isinstance(s, Shape))  # True，因为被注册为Shape的子类

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass
 
class WeChatPay(Payment):
    def pay(self, amount):
        print(f"微信支付 {amount} 元")
 
class AliPay(Payment):
    def pay(self, amount):
        print(f"支付宝支付 {amount} 元")

class LogMixin:
    def log(self, message):
        print(f"[LOG] {message}")
 
class User:
    def __init__(self, name):
        self.name = name
 
class AdminUser(User, LogMixin):  # 混入LogMixin
    def delete_account(self, user):
        self.log(f"删除用户 {user.name}")
        # 其他删除逻辑
 
admin = AdminUser("Admin")
admin.delete_account(User("Alice"))  # 输出: [LOG] 删除用户 Alice

class Engine:
    def start(self):
        print("引擎启动")
 
class Wheel:
    def rotate(self):
        print("车轮旋转")
 
class Car:
    def __init__(self):
        self.engine = Engine()  # 组合Engine
        self.wheels = [Wheel() for _ in range(4)]  # 组合Wheel
 
    def drive(self):
        self.engine.start()
        for wheel in self.wheels:
            wheel.rotate()
        print("汽车行驶中...")
 
car = Car()
car.drive()

# 动态创建类
def say_hello(self):
    print(f"你好，我是 {self.name}")
 
MyClass = type("MyClass", (), {
    "name": "动态类",
    "say_hello": say_hello
})
 
obj = MyClass()
obj.say_hello()  # 输出: 你好，我是 动态类

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        # 类创建前的修改：自动添加version属性
        dct["version"] = "1.0"
        # 还可以修改方法、校验属性等
        return super().__new__(cls, name, bases, dct)
 
class MyClass(metaclass=MyMeta):
    pass
 
print(MyClass.version)  # 输出: 1.0

class ModelMeta(type):
    def __new__(cls, name, bases, dct):
        # 提取类属性中的字段（如title, content）
        fields = {}
        for attr, value in dct.items():
            if isinstance(value, Field):  # 假设Field是字段基类
                fields[attr] = value
        dct["__fields__"] = fields
        return super().__new__(cls, name, bases, dct)
 
class Field:
    def __init__(self, type_):
        self.type = type_
 
class User(metaclass=ModelMeta):
    name = Field(str)
    age = Field(int)
 
print(User.__fields__)  # 输出: {'name': <__main__.Field object at ...>, 'age': <__main__.Field object at ...>}

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 Singleton(metaclass=SingletonMeta):
    pass
 
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # True

def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper
 
@singleton
class MySingleton:
    pass
 
ms1 = MySingleton()
ms2 = MySingleton()
print(ms1 is ms2)  # True

class Circle:
    def draw(self):
        print("画圆形")
 
class Rectangle:
    def draw(self):
        print("画矩形")
 
class ShapeFactory:
    @staticmethod
    def create_shape(shape_type):
        if shape_type == "circle":
            return Circle()
        elif shape_type == "rectangle":
            return Rectangle()
        else:
            raise ValueError(f"不支持的图形类型：{shape_type}")
 
# 使用
factory = ShapeFactory()
circle = factory.create_shape("circle")
circle.draw()  # 画圆形

class Subject:
    def __init__(self):
        self.observers = []
 
    def attach(self, observer):
        self.observers.append(observer)
 
    def detach(self, observer):
        self.observers.remove(observer)
 
    def notify(self, message):
        for observer in self.observers:
            observer.update(message)
 
class Observer:
    def __init__(self, name):
        self.name = name
 
    def update(self, message):
        print(f"{self.name} 收到通知：{message}")
 
# 使用
subject = Subject()
observer1 = Observer("张三")
observer2 = Observer("李四")
 
subject.attach(observer1)
subject.attach(observer2)
subject.notify("有新文章发布！")
 
subject.detach(observer1)
subject.notify("文章已更新！")

import pickle
 
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"
 
# 序列化
person = Person("Bob", 30)
with open("person.pkl", "wb") as f:
    pickle.dump(person, f)
 
# 反序列化
with open("person.pkl", "rb") as f:
    loaded_person = pickle.load(f)
    print(loaded_person)  # 输出: Person(name=Bob, age=30)

import json
 
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
# 自定义编码器
class PersonEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, Person):
            return {"name": o.name, "age": o.age, "__type__": "Person"}
        return super().default(o)
 
# 自定义解码器
def person_decoder(dct):
    if "__type__" in dct and dct["__type__"] == "Person":
        return Person(dct["name"], dct["age"])
    return dct
 
# 序列化
person = Person("Alice", 25)
json_str = json.dumps(person, cls=PersonEncoder)
print(json_str)  # 输出: {"name": "Alice", "age": 25, "__type__": "Person"}
 
# 反序列化
loaded_person = json.loads(json_str, object_hook=person_decoder)
print(loaded_person.name, loaded_person.age)  # Alice 25