今天系统学习了 Python 面向对象编程的核心内容，涵盖从基础的类与对象创建，到继承、方法重写、装饰器等进阶知识点，本文将对这些内容进行全面梳理，帮助理解面向对象的核心逻辑与使用技巧。

 一、类与对象基础

        1. 核心概念

        对象：拥有属性和行为的个体，是面向对象编程的核心载体。
        类：描述一类事物的模板，规定了该类事物的属性和行为（方法），采用大驼峰命名法。
        实例：根据类创建的具体对象，也叫实例对象。
        实例化：根据类创建实例的过程。

        2. 类的定义与实例化

class Person:
    # 初始化方法：给实例添加属性，self代表当前实例对象
    def __init__(self, name, age, height):
        self.name = name  # 实例属性
        self.age = age
        self.height = height

# 实例化：创建具体的实例对象
p1 = Person('Python', 18, 178)
p2 = Person('董小姐', 18, 178)

        3. 实例属性操作

        访问属性：实例.属性名，如p1.name。
        查看属性：实例.__dict__ 可查看实例所有属性（返回字典）。
        追加属性：实例.新属性名 = 值，如p2.gender = '男'。
        特性：每个实例的属性相互独立，互不影响。

二、实例属性与类属性

        1. 实例属性

        定义：通过实例.属性名 = 值 或__init__方法中self.属性名 = 值定义。
        访问：仅能通过实例.属性名访问 / 修改，实例间属性独立。

        2. 类属性

        定义：直接定义在类内部的属性（不在__init__中）。

class Person:
    max_age = 20  # 类属性
    hobby = '篮球'
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

        特性：
                所有实例共享，可理解为 “公共数据”。
                可通过类.属性名或实例.属性名访问（实例访问时先查自身，无则查类）。
                修改：类.属性名 = 新值 会修改类属性；实例.属性名 = 新值 仅给实例新增 / 修改自身属性，不影响类属性。

三、类中的方法

        类中的方法分为实例方法、类方法、静态方法，不同方法的参数和适用场景不同。

        1. 实例方法

        定义：第一个参数为self（接收当前实例），定义在类中的普通方法。
        作用：为实例服务，可访问 / 操作实例属性。
        调用：实例.方法名(参数)（推荐）或类.方法名(实例, 参数)。

class Person:
    def speak(self, msg):  # 实例方法
        print(f'我是{self.name}，想说：{msg}')

p1 = Person('张三', 18, 'male')
p1.speak('我想打麻将')  # 实例调用
Person.speak(p1, '类调用')  # 类调用（需手动传实例）

        查找规则：实例调用方法时，先查自身是否有该方法，无则查所属类。

        2. 类方法

        定义：用@classmethod装饰，第一个参数为cls（接收当前类）。
        作用：为类服务，可访问 / 修改类属性。
        调用：类.方法名(参数)（推荐）或实例.方法名(参数)（实例调用时cls仍指向类）。

class Person:
    hobby = '篮球'
    @classmethod
    def change_hobby(cls, new_hobby):
        cls.hobby = new_hobby  # 修改类属性

Person.change_hobby('足球')  # 类调用
p1.change_hobby('羽毛球')    # 实例调用（不推荐）

        3. 静态方法

        定义：用@staticmethod装饰，无self/cls参数。
        作用：处理与类相关的业务逻辑，不依赖实例 / 类属性。
        调用：类.方法名(参数) 或实例.方法名(参数)。

class Person:
    hobby = '篮球'
    @staticmethod
    def is_adult(age):
        print(Person.hobby)  # 手动访问类属性
        return age >= 18

Person.is_adult(20)  # 类调用
p1.is_adult(17)      # 实例调用

四、继承

        继承允许子类复用父类的属性和方法，是面向对象 “复用” 的核心特性。

        1. 单继承基础

        语法：class 子类(父类):
        父类：也叫超类、基类；        子类：也叫派生类。
        子类初始化：需先初始化父类属性，有两种方式：

class Person:  # 父类
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class Student(Person):  # 子类
    def __init__(self, name, age, gender, stu_id, grade):
        # 方式1：直接调用父类__init__
        Person.__init__(self, name, age, gender)
        # 方式2：通过super()调用（推荐）
        super().__init__(name, age, gender)
        # 子类独有属性
        self.stu_id = stu_id
        self.grade = grade

        2. 方法重写

        子类定义与父类同名的方法，会覆盖父类方法（重写）；若需调用父类方法，可通过父类.方法名(self, 参数)或super().方法名(参数)。

class Student(Person):
    def speak(self, msg):  # 重写父类speak方法
        Person.speak(self, msg)  # 调用父类方法
        # super().speak(msg)  # 等价写法
        print(f'学生说：{msg}')

        3. 多重继承

        语法：class 子类(父类1, 父类2, ...):
注意事项：
        初始化时，super()仅指向第一个继承的父类，多父类初始化需手动调用每个父类的__init__。
        方法查找顺序：遵循类.__mro__（方法解析顺序），先查子类，再按继承顺序查父类。

class Person:
    def __init__(self, name):
        self.name = name
class Work:
    def __init__(self, company, work):
        self.company = company
        self.work = work

class Student(Work, Person):  # 多重继承
    def __init__(self, name, age, company, work):
        Person.__init__(self, name)
        Work.__init__(self, company, work)
        self.age = age

print(Student.__mro__)  # 查看方法查找顺序

        4. 继承相关判断方法

        isinstance(obj, Class)：判断对象是否为指定类 / 子类的实例。
        issubclass(sub, Super)：判断一个类是否为另一个类的子类。

s1 = Student('张三', 18, '男', 2026, 99)
p1 = Person('里斯', 18, 'nan')
print(isinstance(s1, Person))  # True（子类实例属于父类）
print(issubclass(Student, Person))  # True

五、装饰器

        装饰器是 Python 进阶特性，可在不修改原函数的前提下增强函数功能。

        1. 核心逻辑

        装饰器是可调用对象（通常为函数），接收一个函数作为参数，返回一个新函数。
        语法：@装饰器名 放在函数定义上方，等价于原函数 = 装饰器(原函数)。

        2. 基础示例

# 定义装饰器
def say_hello(fn):
    def wrapper(a, b):  # 包装函数，接收原函数参数
        print("hello world")  # 增强逻辑
        return fn(a, b)  # 调用原函数
    return wrapper

# 使用装饰器增强add函数
@say_hello
def add(a, b):
    print(a + b)
    return a + b

add(1, 2)  # 调用增强后的函数，先打印hello world，再执行add逻辑

六、核心总结

        面向对象的核心是 “类 - 实例” 模型，类是模板，实例是具体对象，属性和方法是对象的核心特征。
        方法分为实例方法（依赖 self）、类方法（依赖 cls）、静态方法（无默认参数），需根据场景选择。
        继承是复用的核心，单继承用super()简化父类调用，多重继承需注意方法查找顺序（mro）。
        装饰器是函数增强的优雅方式，遵循 “开放 - 封闭” 原则（不修改原函数，扩展功能）。
        属性查找规则：实例→自身类→父类（逐层向上）；方法同理，重写会覆盖父类方法。