Python练习（6）Python面向对象编程三大特性：封装、继承与多态的15道实战练习题（含答案与深度解析）

引言

在Python编程中，面向对象编程（OOP）的三大特性——封装、继承和多态，是构建复杂软件系统的核心基石。封装实现了数据与操作的有机统一，继承促进了代码的复用与扩展，多态则赋予了程序灵活的接口适配能力。本文通过15道精心设计的实战练习题，系统梳理三大特性的实现机制与典型应用场景，帮助读者构建完整的OOP知识体系。

封装篇（5题）

练习1：银行账户安全封装

class BankAccount:
    def __init__(self, account_number, initial_balance):
        self.__account_number = account_number  # 私有属性
        self._balance = initial_balance          # 受保护属性

    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            print(f"存款成功，当前余额：{self._balance}")
        else:
            print("存款金额必须大于0")

    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            print(f"取款成功，当前余额：{self._balance}")
        else:
            print("余额不足或取款金额无效")

    def get_balance(self):  # 公共接口访问受保护属性
        return self._balance

# 测试代码
account = BankAccount("123456", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())  # 通过公共方法获取余额

答案与解析：

# 执行结果：
# 存款成功，当前余额：1500
# 取款成功，当前余额：1300
# 1300

通过双下划线实现属性私有化，使用单下划线标记受保护属性，通过公共方法提供安全访问接口。

练习2：属性装饰器控制

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight  # 直接赋值会绕过属性验证

    @property
    def weight(self):
        return self.__weight

    @weight.setter
    def weight(self, value):
        if value > 0:
            self.__weight = value
        else:
            print("体重必须为正数")

# 测试代码
p = Person("Alice", -70)  # 直接初始化会绕过验证
print(p.weight)           # 通过属性访问触发验证
p.weight = 65             # 正确设置
print(p.weight)

答案与解析：

# 执行结果：
-70  # 初始化时未触发setter验证
体重必须为正数
65

@property装饰器将方法转换为属性，实现属性的安全访问与修改控制。

练习3：私有方法调用

class SecretData:
    def __init__(self, data):
        self.__data = data

    def __encrypt(self):  # 私有方法
        return f"ENC-{self.__data}"

    def get_encrypted(self):
        return self.__encrypt()

# 测试代码
sd = SecretData("12345")
print(sd.get_encrypted())  # 正确访问方式
print(sd.__encrypt())      # 尝试直接访问私有方法

答案与解析：

# 执行结果：
ENC-12345
AttributeError: 'SecretData' object has no attribute '__encrypt'

私有方法通过名称重整机制（_类名__方法名）实现访问限制，只能通过公共接口调用。

练习4：受保护属性继承

class Vehicle:
    def __init__(self, speed):
        self._speed = speed  # 受保护属性

class Car(Vehicle):
    def drive(self):
        self._speed += 10    # 子类可访问父类受保护属性

# 测试代码
car = Car(60)
car.drive()
print(car._speed)  # 直接访问受保护属性（不推荐）

答案与解析：

# 执行结果：70

受保护属性（单下划线开头）在子类中可直接访问，但外部代码仍可通过实例直接修改，需配合方法实现封装。

练习5：类属性封装

class Config:
    __secret_key = "ABC123"  # 私有类属性

    @classmethod
    def get_secret(cls):
        return cls.__secret_key

# 测试代码
print(Config.get_secret())
print(Config.__secret_key)  # 尝试直接访问

答案与解析：

# 执行结果：
ABC123
AttributeError: type object 'Config' has no attribute '__secret_key'

私有类属性通过名称重整保护，只能通过类方法访问，实现配置参数的安全封装。

继承篇（5题）

练习6：单继承与方法重写

class Animal:
    def speak(self):
        print("动物发出声音")

class Dog(Animal):
    def speak(self):  # 方法重写
        print("汪汪叫")

# 测试代码
animals = [Animal(), Dog()]
for a in animals:
    a.speak()

答案与解析：

# 执行结果：
动物发出声音
汪汪叫

子类通过重写父类方法实现多态，super().speak()可调用父类原始实现。

练习7：多继承与MRO

class A:
    def process(self):
        print("A处理")

class B(A):
    def process(self):
        print("B处理前")
        super().process()

class C(A):
    def process(self):
        print("C处理前")
        super().process()

class D(B, C):
    pass

# 测试代码
D().process()
print(D.mro())  # 查看方法解析顺序

答案与解析：

# 执行结果：
B处理前
C处理前
A处理
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

多继承遵循C3线性化算法，super()按MRO顺序调用父类方法。

练习8：抽象基类实现

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCard(Payment):
    def pay(self, amount):
        print(f"信用卡支付{amount}元")

# 测试代码
card = CreditCard()
card.pay(100)

答案与解析：

# 执行结果：信用卡支付100元

抽象基类通过@abstractmethod强制子类实现特定接口，确保多态行为的规范性。

练习9：Mixin模式

class LoggerMixin:
    def log(self, message):
        print(f"[LOG] {message}")

class Database:
    def save(self):
        self.log("数据保存")

class EnhancedDB(LoggerMixin, Database):
    pass

# 测试代码
db = EnhancedDB()
db.save()

答案与解析：

# 执行结果：[LOG] 数据保存

Mixin类通过多继承为其他类添加横切关注点（如日志），提升代码复用性。

练习10：super()函数应用

class A:
    def __init__(self):
        print("A初始化")
        super().__init__()

class B(A):
    def __init__(self):
        print("B初始化")
        super().__init__()

class C(B):
    def __init__(self):
        print("C初始化")
        super().__init__()

# 测试代码
C()

答案与解析：

# 执行结果：
C初始化
B初始化
A初始化

super()在菱形继承结构中按MRO顺序调用，确保所有父类初始化逻辑执行。

多态篇（5题）

练习11：接口多态

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h

    def area(self):
        return self.w * self.h

# 测试代码
shapes = [Circle(5), Rectangle(4, 6)]
total = sum(s.area() for s in shapes)
print(total)

答案与解析：

# 执行结果：78.5 + 24 = 102.5

不同形状类实现相同接口方法，通过统一接口计算总面积，体现多态特性。

练习12：鸭子类型

class Duck:
    def quack(self):
        print("嘎嘎叫")

class Person:
    def quack(self):
        print("模仿鸭子叫")

def make_quack(obj):
    obj.quack()

# 测试代码
make_quack(Duck())
make_quack(Person())

答案与解析：

# 执行结果：
嘎嘎叫
模仿鸭子叫

Python动态类型语言通过鸭子类型实现多态，只要对象具有相同方法名即可。

练习13：多态与异常处理

class FileHandler:
    def read(self):
        raise NotImplementedError

class TextFile(FileHandler):
    def read(self):
        return "文本内容"

class ImageFile(FileHandler):
    def read(self):
        return b"\x89PNG\r\n"

def process_file(handler):
    try:
        return handler.read()
    except NotImplementedError:
        print("未实现读取方法")

# 测试代码
print(process_file(TextFile()))
print(process_file(ImageFile()))

答案与解析：

# 执行结果：
文本内容
b'\x89PNG\r\n'

抽象基类定义统一接口，子类实现不同读取逻辑，通过多态统一处理。

练习14：多态与类型检查

def serialize(obj):
    if isinstance(obj, int):
        return str(obj)
    elif isinstance(obj, list):
        return ",".join(serialize(i) for i in obj)
    else:
        raise TypeError("不支持的类型")

# 测试代码
print(serialize(123))
print(serialize([1, [2, 3]]))

答案与解析：

# 执行结果：
'123'
'1,2,3'

通过isinstance进行类型检查，实现不同类型数据的序列化多态处理。

练习15：多态与装饰器

def logging(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

class Calculator:
    @logging
    def add(self, a, b):
        return a + b

    @logging
    def multiply(self, a, b):
        return a * b

# 测试代码
calc = Calculator()
print(calc.add(3, 5))
print(calc.multiply(4, 2))

答案与解析：

# 执行结果：
调用 add
8
调用 multiply
8

装饰器为不同方法统一添加日志功能，体现多态在方法层面的应用。

总结

本文通过15道实战练习题，系统梳理了Python面向对象编程三大特性的核心知识点：

1. 封装：通过私有属性、@property装饰器和受保护成员实现数据安全与访问控制
2. 继承：单继承、多继承、MRO机制和抽象基类的应用场景与实现方式
3. 多态：接口多态、鸭子类型、方法重写和装饰器模式在多态中的具体实践

掌握这些核心特性，能够显著提升代码的组织能力、复用性和扩展性。建议读者通过实际编码验证每个案例，加深对面向对象编程思想的理解。

Python爬虫相关文章（推荐）

概述	地址（点击进入）
Python全方位指南	Python（1）Python全方位指南：定义、应用与零基础入门实战
Python基础数据类型详解	Python（2）Python基础数据类型详解：从底层原理到实战应用
Python循环	Python（3）掌握Python循环：从基础到实战的完整指南
Python列表推导式	Python（3.1）Python列表推导式深度解析：从基础到工程级的最佳实践
Python生成器	Python（3.2）Python生成器深度全景解读：从yield底层原理到万亿级数据处理工程实践
Python函数编程性能优化	Python（4）Python函数编程性能优化全指南：从基础语法到并发调优
Python数据清洗	Python（5）Python数据清洗指南：无效数据处理与实战案例解析（附完整代码）
Python邮件自动化	Python（6）Python邮件自动化终极指南：从零搭建企业级邮件系统（附完整源码）
Python通配符基础	Python（7）Python通配符完全指南：从基础到高阶模式匹配实战（附场景化代码）
Python通配符高阶	Python（7 升级）Python通配符高阶实战：从模式匹配到百万级文件处理优化（附完整解决方案）
Python操作系统接口	Python（8）Python操作系统接口完全指南：os模块核心功能与实战案例解析
Python代码计算全方位指南	Python（9）Python代码计算全方位指南：从数学运算到性能优化的10大实战技巧
Python数据类型	Python（10）Python数据类型完全解析：从入门到实战应用
Python判断语句	Python（11）Python判断语句全面解析：从基础到高级模式匹配
Python参数传递	Python（12）深入解析Python参数传递：从底层机制到高级应用实践
Python面向对象编程	Python（13）Python面向对象编程入门指南：从新手到类与对象(那个她)的华丽蜕变
Python内置函数	Python（14）Python内置函数完全指南：从基础使用到高阶技巧
Python参数传递与拷贝机制	Python（15）Python参数传递与拷贝机制完全解析：从值传递到深拷贝实战
Python文件操作	Python（16）Python文件操作终极指南：安全读写与高效处理实践
Python字符编码	Python（17）Python字符编码完全指南：从存储原理到乱码终结实战
Python中JSON的妙用	Python（18）Python中JSON的妙用：详解序列化与反序列化原理及实战案例
Python并发编程	Python（19）Python并发编程：深入解析多线程与多进程的差异及锁机制实战
Python文件与目录操作全攻略	Python（20）Python文件与目录操作全攻略：增删改查及递归实战详解
Python日期时间完全指南	Python（21）Python日期时间完全指南：从基础到实战注意事项
Python Socket编程完全指南	Python（22）Python Socket编程完全指南：TCP与UDP核心原理及实战应用
Python异常处理完全指南	Python（23）Python异常处理完全指南：从防御到调试的工程实践
Python数据压缩	Python（24）Python数据压缩全解析：从基础操作到异常处理实战
Python正则表达式	Python（25）Python正则表达式深度解析：五大匹配模式与七大实战场景
Python数据验证	Python（26）Python数据验证终极指南：从基础校验到高级技巧全覆盖
Python字符串方法	Python（27）Python字符串方法全解析：从基础操作到高效处理技巧
Python循环语句	Python（28）Python循环语句指南：从语法糖到CPython字节码的底层探秘
Python生成器函数	Python（29）Python生成器函数深度解析：asyncio事件循环的底层实现与异步编程实战
Python itertools生成器	Python（30）基于itertools生成器的量子计算模拟技术深度解析
Python PyPy生成器优化	Python（31）PyPy生成器优化深度解析：JIT加速下的Python性能革命
Python基础类型练习题	Python练习（1）Python基础类型操作语法实战：20道实战题解与案例分析（上）
Python基础类型练习题	Python练习（2）Python基础类型操作语法实战：30道实战题解与案例分析（下）
Python循环语句练习题	Python练习（3）Python循环语句的10个核心实战案例（含答案与深度解析）