Python 面向对象编程核心指南

属性是对象的固有特征，比如手机的品牌、人的年龄，操作方式分两种场景：

类内部操作：通过 self.属性名 访问

class Car:
    def show_info(self):
        # 访问对象的 color 属性
        print(f"车辆颜色：{self.color}")

my_car = Car()
my_car.color = "红色"
my_car.show_info()  # 输出：车辆颜色：红色

类外部操作：直接通过 对象名。属性名 添加和获取

# 给对象添加属性
my_phone.brand = "华为"
my_phone.color = "黑色"

# 获取对象属性
print(f"手机品牌：{my_phone.brand}，颜色：{my_phone.color}")

2. 魔法方法：让类更强大

Python 中被双下划线包围的方法称为魔法方法，它们会在特定场景自动调用，无需手动触发：

__del__()：析构方法 删除对象或程序结束时自动调用，用于释放资源：

class Dog:
    def __del__(self):
        print("对象已被销毁，资源释放完成")

dog = Dog()
del dog  # 触发__del__方法，输出对应提示

__str__()：字符串格式化方法 打印对象时自动调用，默认打印内存地址，重写后可自定义输出格式：

class Car:
    def __init__(self, color, number):
        self.color = color
        self.number = number

    def __str__(self):
        return f"颜色：{self.color}，轮胎数：{self.number}"

my_car = Car("白色", 4)
print(my_car)  # 输出：颜色：白色，轮胎数：4

__init__()：初始化方法 创建对象时自动执行，用于初始化对象属性，支持无参和有参两种形式：

class Student:
    # 有参初始化：创建对象时直接赋值
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 创建对象时传递参数
stu = Student("小明", 18)
print(f"姓名：{stu.name}，年龄：{stu.age}")

三、面向对象三大特性：封装、继承、多态

这三大特性是面向对象编程的核心价值所在，也是写出高质量代码的关键。

1. 封装：数据安全与代码复用

封装是将属性和方法写入类中，并可设置访问权限，核心意义是'明确内外边界'：

• 私有成员：在属性或方法名前加 __，只能在类内部使用，外部无法直接访问；
• 访问接口：通过 get_xx() 获取私有属性，set_xx() 修改私有属性，可在接口中添加校验逻辑。

实战案例：封装个人信息类

class People:
    def __init__(self, name, age):
        # 私有属性：外部无法直接修改
        self.__name = name
        self.__age = age

    # 获取私有属性
    def get_name(self):
        return self.__name

    # 修改私有属性：添加类型校验
    def set_age(self, age):
        if not isinstance(age, int):
            print("年龄必须是整数类型！")
            return
        if age < 0 or age > 120:
            print("年龄范围不合法！")
            return
        self.__age = age

    # 私有方法：内部逻辑封装
    def __check_info(self):
        return len(self.__name) > 0 and 0 < self.__age < 120

    # 公共方法：对外提供接口
    def show_info(self):
        if self.__check_info():
            print(f"姓名：{self.__name}，年龄：{self.__age}")
        else:
            print("信息不完整或不合法")

# 使用示例
p = People("Jack", 30)
p.show_info()  # 输出：姓名：Jack，年龄：30
p.set_age(35)  # 合法修改
p.set_age("35")  # 输出：年龄必须是整数类型！

2. 继承：站在巨人的肩膀上

继承允许子类直接复用父类的属性和方法，同时可扩展自己的特性，实现代码复用：

• 单继承：一个子类继承一个父类（最常用）；
• 多继承：一个子类继承多个父类（Python 支持，需注意 MRO 方法解析顺序）；
• 方法重写：子类定义与父类同名的方法，覆盖父类逻辑；
• super() 函数：调用父类的属性和方法，避免硬编码父类名。

实战案例：动物类继承体系

# 父类：抽象动物
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(f"{self.name}正在进食...")

    def call(self):
        print(f"{self.name}发出叫声...")

# 子类：狗，继承自 Animal
class Dog(Animal):
    # 重写父类方法
    def call(self):
        print(f"{self.name}汪汪叫～")

    # 扩展子类特有方法
    def guard(self):
        print(f"{self.name}正在看家护院！")

# 子类：猫，继承自 Animal
class Cat(Animal):
    # 重写父类方法
    def call(self):
        print(f"{self.name}喵喵叫～")

    # 扩展子类特有方法
    def catch_mouse(self):
        print(f"{self.name}正在抓老鼠！")

# 使用示例
dog = Dog("旺财", 3)
dog.eat()   # 继承父类方法
dog.call()  # 调用重写方法
dog.guard() # 调用子类特有方法

cat = Cat("咪宝", 2)
cat.call()  # 调用重写方法
cat.catch_mouse()  # 调用子类特有方法

3. 多态：灵活应对变化

多态是指同一类事物的多种形态，核心是'同一接口，不同实现'：

• 实现条件：存在继承关系、子类重写父类方法、父类引用指向子类对象；
• 核心价值：提高代码可扩展性，无需修改原有框架即可添加新功能。

实战案例：多态在工作场景中的应用

# 父类：抽象狗类
class Dog:
    def work(self):
        print("执行任务...")

# 子类：军犬
class ArmyDog(Dog):
    def work(self):
        print("追击敌人，执行军事任务！")

# 子类：缉毒犬
class DrugDog(Dog):
    def work(self):
        print("搜查毒品，维护社会治安！")

# 人类：与狗协作
class Person:
    def work_with_dog(self, dog):
        # 统一接口，自动适配不同子类
        dog.work()

# 使用示例
army_dog = ArmyDog()
drug_dog = DrugDog()
p = Person()
p.work_with_dog(army_dog)  # 输出：追击敌人，执行军事任务！
p.work_with_dog(drug_dog)  # 输出：搜查毒品，维护社会治安！

四、高级特性：类属性、类方法与静态方法

除了实例属性和实例方法，Python 还提供了类级别的成员，满足更多场景需求：

1. 类属性：类共享的属性

类属性属于整个类，被所有对象共享，常用于存储类级别的公共数据：

class Tool:
    # 类属性：记录创建的工具对象数量
    count = 0

    def __init__(self, name):
        self.name = name

    # 操作类属性：通过类名访问
    Tool.count += 1

# 创建对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
print(Tool.count)  # 输出：2，所有对象共享类属性

2. 类方法：操作类属性的方法

用 @classmethod 装饰，第一个参数是 cls（指向类本身），用于操作类属性：

class Tool:
    count = 0

    def __init__(self, name):
        self.name = name
        Tool.count += 1

    # 类方法：通过 cls 访问类属性
    @classmethod
    def show_count(cls):
        print(f"已创建{cls.count}个工具对象")

Tool("铁锹")
Tool.show_count()  # 输出：已创建 1 个工具对象

3. 静态方法：独立于类和对象的方法

用 @staticmethod 装饰，无需访问类属性或实例属性，相当于类中的普通函数：

class Game:
    # 静态方法：游戏帮助信息
    @staticmethod
    def show_help():
        print("游戏操作指南：")
        print("1. 按 1 开始游戏 2. 按 2 暂停 3. 按 3 退出")

# 直接通过类名调用，无需创建对象
Game.show_help()

五、实战案例：综合运用面向对象特性

案例：烤地瓜模拟器

需求：实现烤地瓜的完整流程，包括烤制时间对应生熟状态、添加调料等功能。

class SweetPotato:
    def __init__(self):
        # 实例属性：烤制时间、生熟状态、调料列表
        self.cook_time = 0
        self.cook_state = "生的"
        self.condiments = []

    # 烤制方法
    def cook(self, time):
        self.cook_time += time
        # 根据时间判断生熟状态
        if 0 <= self.cook_time < 3:
            self.cook_state = "生的"
        elif 3 <= self.cook_time < 5:
            self.cook_state = "半生不熟"
        elif 5 <= self.cook_time < 8:
            self.cook_state = "熟了"
        else:
            self.cook_state = "烤糊了"

    # 添加调料方法
    def add_condiment(self, condiment):
        self.condiments.append(condiment)

    # 自定义打印格式
    def __str__(self):
        return f"烤制时间：{self.cook_time}分钟，状态：{self.cook_state}，调料：{self.condiments}"

# 使用示例
digua = SweetPotato()
print(digua)  # 初始状态
digua.cook(2)
digua.add_condiment("白糖")
print(digua)  # 烤 2 分钟后
digua.cook(4)
digua.add_condiment("辣椒面")
print(digua)  # 再烤 4 分钟后

六、学习总结与进阶建议

1. 核心知识点梳理

• 思维层面：从'步骤导向'转变为'对象导向'，学会抽象现实事物；
• 基础层面：掌握类与对象的定义、属性与方法的操作、self 关键字；
• 特性层面：理解封装（数据安全）、继承（代码复用）、多态（灵活扩展）的核心价值；
• 高级层面：区分实例成员与类成员，合理使用魔法方法优化类设计。

2. 进阶建议

多做实战项目：尝试用面向对象思想重构原有代码，比如实现学生管理系统、图书管理系统；研究优秀源码：阅读 Python 标准库或第三方框架的源码，学习专业的面向对象设计；深入设计模式：面向对象是设计模式的基础，后续可学习单例模式、工厂模式等常用设计模式。