一、类的方法（三大类型）

类的方法是定义在类内部的函数，分为三大类：实例方法、类方法、静态方法。

方法类型	定义标识	第一个参数	调用方式
实例方法	无装饰器	self	实例对象.方法名()
类方法	@classmethod装饰器	cls	实例.方法名() / 类名.方法名()
静态方法	@staticmethod装饰器	无(self/cls)	实例.方法名() / 类名.方法名()

1. 实例方法（最常用）

定义：类内普通函数，第一个参数必须是 self（代表当前实例对象）。
调用：必须通过实例对象调用，self 由 Python 自动传入。
作用：访问或修改实例属性，实现对象的专属行为。

class Student:
    def show(self):   # 实例方法
        print(f"我叫{self.name}，今年{self.age}，性别{self.sex}")

2. 类方法

定义：用 @classmethod 装饰器，第一个参数必须是 cls（代表类对象本身）。
调用：可通过类名或实例对象调用，cls 由 Python 自动传入。
作用：访问或修改类属性，或实现工厂方法。

class Student:
    total = 0

    @classmethod
    def show_total(cls):   # 类方法
        print(f"本校学生总数为：{cls.total}")

3. 静态方法

定义：用 @staticmethod 装饰器，无 self 或 cls 参数，和普通函数几乎一样。
调用：可通过类名或实例对象调用。
作用：实现和类相关但不依赖类或实例属性的工具函数。

class Student:
    school = "第一中学"

    @staticmethod
    def show_school():   # 静态方法
        print(f"本校名为：{Student.school}")

4. 完整示例

class Student:
    school = "第一中学"   # 类属性
    total = 0             # 类属性

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        Student.total += 1   # 每次创建实例，总数加1

    def show(self):   # 实例方法
        print(f"我叫{self.name}，今年{self.age}，性别{self.sex}")

    @classmethod
    def show_total(cls):   # 类方法
        print(f"本校学生总数为：{cls.total}")

    @staticmethod
    def show_school():   # 静态方法
        print(f"本校名为：{Student.school}")

# 实例化
student1 = Student("张三", 18, '男')
student2 = Student("李四", 19, '女')
student3 = Student("王五", 20, '男')

Student.show_total()     # 调用类方法
Student.show_school()    # 调用静态方法
student1.show()          # 调用实例方法
student2.show()
student3.show()

5. 关键注意点

1. self 和 cls 不能省略：实例方法的 self、类方法的 cls 是必选第一个参数，定义时不能少。静态方法无 self 和 cls，传参和普通函数完全一致。

2. 属性访问权限：

   • 实例方法：可访问实例属性（self.xxx）和类属性（cls.xxx 或 类名.xxx）
   • 类方法：只能访问类属性（cls.xxx），不能访问实例属性
   • 静态方法：不能直接访问类属性或实例属性（除非手动传入）

3. 调用方式的语义：

   • 实例方法：必须用实例调用（语义上是“对象的行为”）
   • 类方法和静态方法：推荐用类名调用（语义上是“类的工具”），用实例调用虽不报错但不合设计逻辑

6. 实战场景选择

• 用实例方法：当逻辑需要操作某个具体对象的属性时（如修改某本书的价格、展示某本书的信息）
• 用类方法：当逻辑需要操作所有对象共享的类属性，或需要批量创建实例时（如统一修改配置、快速创建特价商品）
• 用静态方法：当逻辑是工具函数，和类或实例属性无关，但属于类的业务范畴时（如价格校验、格式转换）

方法总结：

1. 类的方法分三类：实例方法（self，操作实例属性）、类方法（@classmethod + cls，操作类属性）、静态方法（@staticmethod，独立工具函数）
2. 核心区别：参数（self / cls / 无）决定了方法能访问的属性范围，调用方式决定了语义合理性
3. 选择原则：优先用实例方法；类级逻辑用类方法；无属性依赖的工具函数用静态方法

二、继承的基本定义

继承是OOP三大核心特性之一（封装、继承、多态）。简单来说，继承允许你基于一个已有的“父类（基类）”创建新的“子类（派生类）”，子类会自动拥有父类的属性和方法，还能扩展或重写自己的特性。核心价值是代码复用和逻辑分层。

1. 核心术语

• 父类（基类/超类）：被继承的类，提供通用的属性和方法（如“动物类”）
• 子类（派生类）：继承父类的类，可复用父类功能，也可自定义（如“狗类”“猫类”）

2. 基本定义格式

# 定义父类（基类）
class 父类名:
    def 父类方法(self):
        pass

# 定义子类（派生类），继承父类
class 子类名(父类名):
    def 子类方法(self):
        pass

3. 基础示例：单继承（最常用）

以“动物(Animal)”为父类，“狗(Dog)”为子类：

class Animal:
    def show(self):
        print("我是一个动物")

    def move(self):
        print("动物在移动")

class Dog(Animal):
    def bark(self):
        print("小狗在叫")

d1 = Dog()
d1.show()    # 调用父类方法：我是一个动物
d1.move()    # 调用父类方法：动物在移动
d1.bark()    # 调用子类方法：小狗在叫

三、继承的核心特性

1. 方法重写（Override）

子类可以定义和父类同名的方法，覆盖父类的逻辑。这是实现“多态”的基础。
如需在子类中调用父类的原方法，用 super()（推荐）或 父类名.方法名(self, 参数)。

class Animal:
    def show(self):
        print("我是一个动物")

class Dog(Animal):
    def show(self):   # 重写父类方法
        print("我是一个小狗")

d1 = Dog()
d1.show()   # 我是一个小狗

2. 继承父类构造方法（init）

基本继承（自动调用父类构造方法）：
当子类没有定义 init 方法时，会自动调用父类的构造方法。

class Animal:
    def __init__(self, name):
        self.name = name
        print(f"我叫{self.name}")

class Dog(Animal):
    pass

dog = Dog("旺财")   # 我叫旺财

完全重写构造方法：
如果子类定义了 init 但没有调用父类 init，父类的构造方法不会执行。

class Animal:
    def __init__(self, name):
        self.name = name
        print(f"动物：{self.name}")

class Dog(Animal):
    def __init__(self, name):
        self.name = name
        print(f"小狗：{self.name}")

dog = Dog("旺财")   # 小狗：旺财（父类构造方法未执行）

3. 多继承（Python支持，但慎用）

一个子类可以继承多个父类，格式：class 子类名(父类1, 父类2, …)。
注意：多继承可能导致“菱形问题”（属性/方法查找顺序混乱），Python用MRO（方法解析顺序）解决，优先继承排在前面的父类。

class User1:
    def show(self):
        print("父类1的方法")

class User2:
    def move(self):
        print("父类2的方法")

class User(User1, User2):
    def own(self):
        print("子类自己的方法")

user = User()
user.show()   # 调用父类1方法
user.move()   # 调用父类2方法
user.own()    # 调用子类方法

4. 查看继承关系

• 子类.bases：查看子类的直接父类
• 子类.mro()：查看方法解析顺序（MRO）

print(User.__bases__)   # (<class '__main__.User1'>, <class '__main__.User2'>)
print(User.mro())       # 查看完整的方法解析顺序

四、继承的实战场景

1. 代码复用：将多个类的通用属性和方法抽成父类，子类只需关注自己的特有逻辑（如“学生”“老师”都继承“人”类）
2. 逻辑分层：父类定义通用规则，子类实现具体细节（如“图形”父类定义 area() 方法，子类“圆形”“矩形”分别重写计算面积的逻辑）
3. 扩展已有类：基于Python内置类或第三方库的类扩展功能（如自定义 MyList(list)，新增去重方法）

今日核心总结

1. 三大方法类型：

   • 实例方法（self）：操作实例属性，通过对象调用
   • 类方法（@classmethod + cls）：操作类属性，通过类名或对象调用
   • 静态方法（@staticmethod）：工具函数，通过类名或对象调用

2. 继承的核心价值：代码复用和逻辑分层，子类自动拥有父类的属性和方法

3. 关键语法：

   • class 子类(父类) 定义继承
   • super() 调用父类方法（推荐）
   • __bases__ 和 mro() 查看继承关系

4. 方法重写：子类定义与父类同名方法，覆盖父类逻辑

5. 多继承注意事项：优先用单继承，多继承需注意MRO顺序；子类构造方法需通过 super().__init__() 初始化父类属性

注:已经使用DeepSeek进行整理精简核心内容，些许不理解的配合个人笔记进行理解。