在Python中，基类、元类和抽象类是面向对象编程的重要概念。以下是对这三种类的介绍及其使用示例

1. 基类 (Base Class)

基类是其他类的父类，提供了共享的属性和方法。其他类可以继承基类，从而获得其功能。

继承的执行顺序

单一继承：当一个类继承自一个基类时，基类的构造函数（init）会在子类的构造函数之前被调用。

class Animal:  # 基类
    def __init__(self):
        print("Animal initialized")

    def speak(self):
        return "Animal speaks"


class Dog(Animal):  # Dog类继承自Animal类
    def __init__(self):
        super().__init__()  # 调用基类构造函数
        print("Dog initialized")

    def speak(self):
        return "Woof!"


class Cat(Animal):  # Cat类继承自Animal类
    def __init__(self):
        super().__init__()  # 调用基类构造函数
        print("Cat initialized")

    def speak(self):
        return "Meow!"


# 使用示例
dog = Dog()
cat = Cat()
print(dog.speak())  # 输出: Woof!
print(cat.speak())  # 输出: Meow!

多重继承：在多重继承中，Python使用一种称为C3线性化（C3 Linearization）的算法来确定方法解析顺序（MRO，Method Resolution Order）。

MRO决定了在调用方法时，Python将按照什么顺序查找类及其基类。

class A:
    def method(self):
        print("Method from A")


class B(A):
    def method(self):
        print("Method from B")
        super().method()  # 调用A的方法


class C(A):
    def method(self):
        print("Method from C")
        super().method()  # 调用A的方法


class D(B, C):  # D类同时继承B和C
    def method(self):
        print("Method from D")
        super().method()  # 调用B的方法


d = D()
d.method()
# 输出:
# Method from D
# Method from B
# Method from C
# Method from A

查看MRO：可以使用ClassName.__mro__或ClassName.mro()来查看类的MRO。

print(D.__mro__)
# 输出:
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

2. 元类 (Metaclass)

元类是用于创建类的类。通过元类，可以控制类的创建过程，修改类的属性和方法

class Meta(type):  # 定义一个元类
    def __new__(cls, name, bases, attrs):
        # 添加一个新的方法
        def new_method(self):
            return "This is a new method added by the metaclass."

        attrs["new_method"] = new_method

        # 添加一个只读属性
        attrs["readonly_attr"] = property(lambda self: "This is read-only")

        # 添加一个欢迎信息
        attrs["greeting"] = "Hello"

        # 添加一个类方法
        @classmethod
        def class_method(cls):
            return "This is a class method added by the metaclass."

        attrs["class_method"] = class_method

        # 添加一个静态方法
        @staticmethod
        def static_method():
            return "This is a static method added by the metaclass."

        attrs["static_method"] = static_method

        return super().__new__(cls, name, bases, attrs)


class MyClass(metaclass=Meta):  # 使用Meta作为MyClass的元类
    pass


# 使用示例
obj = MyClass()
print(obj.greeting)  # 输出: Hello
print(obj.new_method())  # 输出: This is a new method added by the metaclass.
print(obj.readonly_attr)  # 输出: This is read-only
# obj.readonly_attr = "Hi" # AttributeError: can't set attribute，无法修改

# 调用类方法
print(MyClass.class_method())  # 输出: This is a class method added by the metaclass.

# 调用静态方法
print(MyClass.static_method())  # 输出: This is a static method added by the metaclass.

# 在日常中，元类可以用于<例如django orm>：
# 1. 自动注册类：在定义类时，使用元类可以自动将类注册到某个注册表中。
# 2. 类的自动配置：元类可以在类定义时自动配置类的某些属性或方法。
# 3. 类的验证：元类可以在类定义时验证类的定义是否符合某些规则。
# 4. 类的修改：元类可以在类定义时修改类的定义，例如添加或修改方法。
# 5. 类的继承控制：元类可以控制类的继承关系，例如限制某些类不能被继承。

3. 抽象类 (Abstract Class)

抽象类是不能被实例化的类，通常包含一个或多个抽象方法（没有实现的方法）。它们用于定义接口，子类必须实现这些抽象方法。

from abc import ABC, abstractmethod


class PaymentGateway(ABC):  # 抽象类
    @abstractmethod
    def pay(self, amount):
        pass

    @abstractmethod
    def refund(self, amount):
        pass


class Alipay(PaymentGateway):  # Alipay类继承自PaymentGateway类
    def __init__(self, account):
        self.account = account

    def pay(self, amount):
        print(f"使用支付宝账号{self.account}支付{amount}元")

    def refund(self, amount):
        print(f"使用支付宝账号{self.account}退款{amount}元")


class WechatPay(PaymentGateway):  # WechatPay类继承自PaymentGateway类
    def __init__(self, account):
        self.account = account

    def pay(self, amount):
        print(f"使用微信账号{self.account}支付{amount}元")

    def refund(self, amount):
        print(f"使用微信账号{self.account}退款{amount}元")


class BankTransfer(PaymentGateway):  # BankTransfer类继承自PaymentGateway类
    def __init__(self, account):
        self.account = account

    def pay(self, amount):
        print(f"使用银行账号{self.account}支付{amount}元")

    def refund(self, amount):
        print(f"使用银行账号{self.account}退款{amount}元")


# 使用示例
alipay = Alipay("1234567890")
wechatpay = WechatPay("wechat123")
banktransfer = BankTransfer("1234567890")

orders = [
    {"amount": 100, "payment_gateway": alipay},
    {"amount": 200, "payment_gateway": wechatpay},
    {"amount": 300, "payment_gateway": banktransfer},
]

for order in orders:
    order["payment_gateway"].pay(order["amount"])
    order["payment_gateway"].refund(order["amount"])
# 使用支付宝账号1234567890支付100元
# 使用支付宝账号1234567890退款100元
# 使用微信账号wechat123支付200元
# 使用微信账号wechat123退款200元
# 使用银行账号1234567890支付300元
# 使用银行账号1234567890退款300元