本文将结合课堂笔记，系统梳理 Python 面向对象的核心知识点，包括魔法方法、权限控制、继承、多态、抽象类等关键内容，帮助大家理解并掌握面向对象编程的精髓。

一、魔法方法

1. 核心概念

        以__xxx__命名的特殊方法被称为魔法方法（下划线开头与结尾），其核心特点是无需手动调用，Python 解释器会在特定场景下自动触发执行。

2. 常用魔法方法及触发场景

魔法方法	触发条件	示例用途
__init__	创建类实例时	初始化实例属性（如 name、age）
__str__	调用print(实例对象)或str(对象)时	自定义实例的字符串展示格式
__len__	执行len(对象)时	定义实例的 “长度”（如返回实例__dict__的长度）
__lt__	执行对象1 < 对象2时	自定义小于比较规则（如按 age 比较）
__gt__	执行对象1 > 对象2时	自定义大于比较规则（如按 age 比较）
__eq__	执行对象1 == 对象2时	自定义相等比较规则（如按 age 比较）
__getattr__	访问实例不存在的属性时	统一处理属性访问异常，或自定义属性获取逻辑

3. 代码示例

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f'{self.name}, {self.age}'
    
    def __len__(self):
        return len(self.__dict__)
    
    def __lt__(self, other):
        return self.age < other.age

p1 = Person('里斯',20)
print(p1)  # 自动触发__str__，输出：里斯, 20
print(len(p1))  # 自动触发__len__，输出：2（name和age两个属性）

二、属性权限控制

        Python 通过属性命名规范和property装饰器实现属性的权限管理，分为三种权限等级：

1. 三种属性权限

权限类型	命名规范	访问范围
共有属性	直接命名（如self.name）	类内部、子类、类外部均可访问
受保护属性	单下划线开头（如self._age）	类内部、子类可访问；类外部不建议访问（无语法限制，仅为规范）
私有属性	双下划线开头（如self.__idcard）	仅类内部可访问；外部无法直接访问（可通过_类名__属性名强制访问，不推荐）

2. Getter/Setter 方法（property 装饰器）

        为了安全地访问和修改受保护 / 私有属性，可通过@property（getter）和@属性名.setter（setter）装饰器封装操作：

class Person:
    def __init__(self, name, age, card):
        self._age = age   # 受保护属性
        self.__idcard = card  # 私有属性
    
    # age的getter方法：访问p1.age时触发
    @property
    def age(self):
        return self._age
    
    # age的setter方法：修改p1.age时触发
    @age.setter
    def age(self, new_age):
        self._age = new_age
    
    # idcard的getter方法
    @property
    def idcard(self):
        return self.__idcard

p1 = Person('张三',18,20)
print(p1.age)  # 调用getter，输出18
p1.age = 21    # 调用setter，修改_age为21

三、object 类：所有类的最终祖先

Python 中所有类（无论是否显式声明）最终都会继承object类，因此：
        所有对象都是object的间接实例（如isinstance(52.0, object)返回 True）；
        可通过issubclass(类名, object)验证类的继承关系（如issubclass(int, object)返回 True）；
        object类提供了所有对象的基础方法（可通过object.__dict__查看）。

四、继承与多态

1. 继承：代码复用的核心

        继承是子类复用父类代码的方式，子类可继承父类的属性和方法，也可重写父类方法实现自定义逻辑。

2. 多态：同名方法的不同行为

        多态指 “不同对象使用同一个方法名调用时，表现出不同的行为”，分为两种实现风格：

（1）标准多态（严格多态）

        满足三个条件：
                必须有继承关系；
                子类和父类拥有同名方法；
                被同一个方法名调用。

（2）鸭子多态（Python 主流风格）

        核心思想：不关注对象的类型，只关注对象是否能执行某一行为（“看起来像鸭子，叫起来也像鸭子，那它就是鸭子”）。

3. 代码示例

# 父类
class Animal:
    def say(self):
        print('spake')

# 子类重写父类方法（标准多态）
class Dog(Animal):
    def say(self):
        print('woof')

# 无继承关系，但有同名方法（鸭子多态）
class Car:
    def say(self):
        print('car')

# 统一调用方法，体现多态
def sound(animal):
    animal.say()

sound(Animal())  # 输出：spake
sound(Dog())     # 输出：woof
sound(Car())     # 输出：car（鸭子多态，无继承仍可调用）

五、抽象类：规范子类的 “规则制定者”

1. 核心概念

        抽象类是不能被实例化的类，核心作用是定义规范（抽象方法），强制子类实现指定方法，保证代码的统一性和规范性。
        抽象类可包含抽象方法（仅定义规则，无实现）和普通方法（有实现）；
        子类继承抽象类后，必须实现所有抽象方法，否则子类仍为抽象类，无法实例化。

2. 实现方式

        需借助abc模块的ABC（抽象基类）和@abstractmethod装饰器：

from abc import ABC, abstractmethod

# 抽象类（继承ABC）
class MustRun(ABC):
    # 抽象方法（强制子类实现）
    @abstractmethod
    def run(self):
        pass

# 子类必须实现run方法
class Person(MustRun):
    def run(self):
        print('人在跑步')

p1 = Person()
p1.run()  # 输出：人在跑步

# 抽象类无法实例化
# m1 = MustRun()  # 报错：Can't instantiate abstract class MustRun with abstract method run

六、面向对象核心特性总结

特性	核心作用	关键要点
封装	隐藏数据，保证安全性	共有 / 受保护 / 私有属性；getter/setter
继承	复用代码，减少冗余	所有类最终继承 object；子类可重写父类方法
多态	同名方法，不同行为	标准多态（继承 + 重写）；鸭子多态（无继承，只看方法）
抽象类	制定规则，强制子类实现方法	不能实例化；抽象方法需子类实现

        Python 面向对象编程的核心是通过封装、继承、多态和抽象类构建高内聚、低耦合的代码结构，而魔法方法则为类和实例提供了更灵活的自定义能力。