# 1. 定义类：用class关键字，类名首字母大写（约定俗成）class Person:    # 类属性：属于类本身，所有实例共享    species = "人类"    # 构造方法：初始化实例属性，创建实例时自动调用    # self：代表当前实例，必须作为第一个参数    def __init__(self, name, age):        # 实例属性：属于单个实例，每个实例的属性值可以不同        self.name = name        self.age = age    # 实例方法：操作实例属性的方法，第一个参数必须是self    def introduce(self):        print(f"我叫{self.name}，今年{self.age}岁，是{self.species}")# 2. 实例化：用类名()创建对象，传入__init__所需参数person1 = Person("张三", 25)person2 = Person("李四", 30)# 3. 调用实例方法person1.introduce()  # 输出：我叫张三，今年25岁，是人类person2.introduce()  # 输出：我叫李四，今年30岁，是人类# 4. 访问属性（类属性和实例属性）print(person1.name)  # 实例属性：张三print(Person.species)  # 类属性：人类print(person2.species)  # 实例可访问类属性：人类

# 父类：Personclass Person:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce(self):        print(f"我叫{self.name}，今年{self.age}岁")# 子类：Student，继承自Personclass Student(Person):    # 重写父类的构造方法（添加子类特有属性）    def __init__(self, name, age, student_id):        # 调用父类的构造方法，复用父类的属性初始化逻辑        super().__init__(name, age)        # 子类特有属性        self.student_id = student_id    # 子类特有方法    def study(self):        print(f"学生{self.name}（学号：{self.student_id}）正在学习")# 实例化子类stu = Student("王五", 18, "2026001")# 调用父类的方法stu.introduce()  # 输出：我叫王五，今年18岁# 调用子类的方法stu.study()      # 输出：学生王五（学号：2026001）正在学习

class Animal:    def speak(self):        print("动物发出叫声")class Dog(Animal):    # 重写父类的speak方法    def speak(self):        print("汪汪汪")class Cat(Animal):    # 重写父类的speak方法    def speak(self):        print("喵喵喵")# 定义一个统一的调用函数def animal_speak(animal):    animal.speak()# 传入不同实例，调用同一个方法，表现不同行为animal_speak(Animal())  # 输出：动物发出叫声animal_speak(Dog())     # 输出：汪汪汪animal_speak(Cat())     # 输出：喵喵喵

class Person:    def __init__(self, name, age):        self._name = name  # 约定私有属性，不建议直接访问        self.__age = age   # 真正的私有属性，触发名称修饰    # 访问私有属性的接口方法    def get_age(self):        return self.__age    def set_age(self, age):        if 0 < age < 120:  # 增加数据校验            self.__age = age        else:            raise ValueError("年龄必须在0-120之间")p = Person("张三", 25)print(p._name)  # 可以访问，但不推荐（违反约定）# print(p.__age)  # 报错：AttributeError: 'Person' object has no attribute '__age'print(p.get_age())  # 正确访问方式：通过接口方法p.set_age(30)print(p.get_age())

class Person:    def __init__(self, name, age):        self._name = name        self._age = age  # 这里用单下划线，配合property实现封装    @property    def age(self):  # 替代getter方法，调用时：p.age        return self._age    @age.setter    def age(self, age):  # 替代setter方法，赋值时：p.age = 30        if 0 < age < 120:            self._age = age        else:            raise ValueError("年龄必须在0-120之间")    @property    def name(self):  # 只读属性（没有setter），无法赋值        return self._namep = Person("张三", 25)print(p.age)  # 调用getter，无需括号，输出25p.age = 30    # 调用setter，赋值# p.name = "李四"  # 报错：AttributeError: can't set attribute 'name'（只读属性）

class A:    def show(self):        print("A的show方法")class B(A):    def show(self):        print("B的show方法")class C(A):    def show(self):        print("C的show方法")class D(B, C):  # 多重继承，B和C都继承自A    passd = D()d.show()  # 输出什么？B的show方法还是C的show方法？

print(D.__mro__)# 输出：(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)# 调用顺序：D → B → C → A → object

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

class Dog:    def bark(self):        print("汪汪汪")class Cat:    def bark(self):  # 猫也有bark方法，虽然逻辑不同        print("喵喵喵")class Duck:    def bark(self):  # 鸭子也有bark方法        print("嘎嘎嘎")# 统一调用方法，不关心对象具体类型def animal_bark(animal):    animal.bark()# 传入不同类型的对象，表现出不同行为（多态）animal_bark(Dog())  # 汪汪汪animal_bark(Cat())  # 喵喵喵animal_bark(Duck()) # 嘎嘎嘎

from abc import ABCMeta, abstractmethod# 抽象基类，不能被实例化class Animal(metaclass=ABCMeta):    @abstractmethod  # 抽象方法，子类必须实现    def bark(self):        passclass Dog(Animal):    def bark(self):  # 必须实现bark方法，否则报错        print("汪汪汪")class Cat(Animal):    # 忘记实现bark方法，会报错    pass# dog = Dog()  # 正常实例化# cat = Cat()  # 报错：TypeError: Can't instantiate abstract class Cat with abstract method bark

# 用class定义类class Person:    species = "人类"    def say_hello(self):        print("Hello")# 用type创建类，和上面等价def say_hello(self):    print("Hello")Person = type("Person", (object,), {"species": "人类", "say_hello": say_hello})p = Person()print(p.species)  # 人类p.say_hello()     # Hello

class UpperMeta(type):    # __new__：创建类的方法，cls是要创建的类，name是类名，bases是父类元组，attrs是类属性    def __new__(cls, name, bases, attrs):        # 强制类名大写        if not name.isupper():            raise ValueError("类名必须大写！")        # 给类添加一个统一的属性        attrs["create_time"] = "2026-03-16"        return super().__new__(cls, name, bases, attrs)# 用自定义元类创建类，指定metaclass=UpperMetaclass PERSON(metaclass=UpperMeta):    passclass student(metaclass=UpperMeta):  # 类名小写，报错    pass# 报错：ValueError: 类名必须大写！# p = PERSON()# print(p.create_time)  # 2026-03-16（元类添加的统一属性）

class IntDescriptor:    # 初始化时，指定属性名    def __init__(self, name):        self.name = name    # 访问属性时调用    def __get__(self, instance, owner):        return instance.__dict__[self.name]  # 从实例的字典中获取值    # 赋值时调用，校验类型    def __set__(self, instance, value):        if not isinstance(value, int):            raise TypeError(f"{self.name}必须是整数类型！")        instance.__dict__[self.name] = value  # 将值存入实例的字典    # 删除属性时调用    def __delete__(self, instance):        del instance.__dict__[self.name]# 使用描述符作为类的属性class Student:    # 用IntDescriptor控制age和score属性，必须是整数    age = IntDescriptor("age")    score = IntDescriptor("score")    def __init__(self, name, age, score):        self.name = name        self.age = age        self.score = scores = Student("李四", 20, 90)print(s.age)  # 20（调用__get__）s.age = 21    # 调用__set__，正常赋值# s.age = "22"  # 报错：TypeError: age必须是整数类型！# del s.age     # 调用__delete__，删除age属性

def log_decorator(cls):    # 定义一个新的方法，用于日志输出    def log(self, message):        print(f"[{cls.__name__}] 日志：{message}")    # 给原类添加log方法    cls.log = log    # 返回增强后的类    return cls# 用装饰器装饰类@log_decoratorclass Person:    def __init__(self, name):        self.name = namep = Person("张三")p.log("用户登录成功")  # 输出：[Person] 日志：用户登录成功

def permission_decorator(permission):    # 装饰器工厂，接收权限参数    def decorator(cls):        # 给类添加权限属性        cls.permission = permission        # 重写__init__方法，添加权限校验        original_init = cls.__init__        def new_init(self, *args, **kwargs):            original_init(self, *args, **kwargs)            print(f"当前类权限：{self.permission}")        cls.__init__ = new_init        return cls    return decorator# 给不同的类添加不同的权限@permission_decorator("admin")class Admin:    pass@permission_decorator("user")class User:    passadmin = Admin()  # 输出：当前类权限：adminuser = User()    # 输出：当前类权限：user

class Person:    __slots__ = ("name", "age")  # 限制实例只能有name和age两个属性p = Person()p.name = "张三"p.age = 25# p.gender = "男"  # 报错：AttributeError: 'Person' object has no attribute 'gender'# 注意：定义__slots__后，实例不再有__dict__属性# print(p.__dict__)  # 报错：AttributeError: 'Person' object has no attribute '__dict__'

class MathUtils:    PI = 3.1415926  # 类属性    @classmethod    def circle_area(cls, radius):  # 类方法，操作类属性PI        return cls.PI * radius ** 2    @staticmethod    def add(a, b):  # 静态方法，和类、实例无关        return a + b# 类方法：无需创建实例，直接用类名调用print(MathUtils.circle_area(2))  # 12.5663704# 静态方法：无需创建实例，直接用类名调用print(MathUtils.add(10, 20))     # 30# 实例也可以调用类方法和静态方法，但不推荐mu = MathUtils()print(mu.circle_area(3))  # 28.2743334

from abc import ABCMeta, abstractmethod# 1. 自定义描述符：校验整数类型class IntDescriptor:    def __init__(self, name):        self.name = name    def __get__(self, instance, owner):        return instance.__dict__[self.name]    def __set__(self, instance, value):        if not isinstance(value, int) or value < 0:            raise ValueError(f"{self.name}必须是非负整数！")        instance.__dict__[self.name] = value    def __delete__(self, instance):        del instance.__dict__[self.name]# 2. 类装饰器：添加日志功能def log_decorator(cls):    def log(self, message):        print(f"[{cls.__name__}] {message}")    cls.log = log    return cls# 3. 抽象基类：约束子类必须实现show_info方法class BaseStudent(metaclass=ABCMeta):    @abstractmethod    def show_info(self):        pass# 4. 学生类：综合运用上述特性@log_decoratorclass Student(BaseStudent):    # 用描述符控制属性    age = IntDescriptor("age")    score = IntDescriptor("score")    def __init__(self, name, age, score):        self.name = name        self.age = age        self.score = score        self.log(f"学生{name}创建成功")    # property装饰器：只读属性（姓名不能修改）    @property    def name(self):        return self._name    @name.setter    def name(self, value):        if not isinstance(value, str) or len(value) == 0:            raise ValueError("姓名必须是非空字符串！")        self._name = value    # 实现抽象方法    def show_info(self):        print(f"姓名：{self.name}，年龄：{self.age}，成绩：{self.score}")# 测试代码try:    s1 = Student("张三", 20, 95)    s1.show_info()  # 姓名：张三，年龄：20，成绩：95    s1.age = 21     # 正常赋值    # s1.age = -1    # 报错：ValueError: age必须是是非负整数！    # s1.name = ""   # 报错：ValueError: 姓名必须是是非空字符串！    s1.log("修改年龄为21")except ValueError as e:    print(e)