Python 练习 002

← 返回主页

正确

已完成

总题数

查看做题记录 ▼

做题记录

暂无记录

答题详情

一、选择题（10 题）

第 1 题选择题

面向对象中，封装主要解决的问题是？

A 让所有代码都不能被访问

B 数据和行为的组织，以及访问边界控制

C 让类不能被继承

D 让程序只能按顺序执行

✓ 正确

解析：封装的核心是把相关的数据和操作方法组织到类里，同时用私有属性和公共接口控制外部访问方式（访问边界）。

第 2 题选择题

下列关于继承的说法正确的是？

A 子类不能使用父类方法

B 继承可以减少重复代码，并让子类复用父类能力

C 继承会让所有类完全一样

D Python 不支持继承

✓ 正确

解析：继承的核心价值就是复用。子类继承父类后自动获得父类的属性和方法，避免重复编写相同代码。

第 3 题选择题

定义 Dog 类继承 Animal 类，正确写法是？

A class Dog[Animal]:

B class Dog(Animal):

C class Dog:Animal

D class Dog extends Animal:

✓ 正确

解析：Python 继承语法：class 子类名(父类名):。注意是圆括号。

第 4 题选择题

子类重新定义父类同名方法，这种行为叫？

A 方法删除

B 方法重写

C 方法导入

D 方法隐藏文件

✓ 正确

解析：方法重写（Override）是子类定义与父类同名的方法，从而在子类中提供不同的实现。

第 5 题选择题

子类重写父类方法后，子类对象调用该同名方法时，默认会优先执行？

A 子类自己的方法

B 父类的方法

C 随机方法

D object 中的方法

✓ 正确

解析：方法查找遵循「就近原则」：先在子类自身查找，找到即停止，找不到才去父类。

第 6 题选择题

在 Python3 中，子类调用父类初始化方法，推荐写法是？

A super().__init__(参数)

B super(self).__init__(参数)

C 父类.__init__(参数)

D self.super().__init__(参数)

✓ 正确

解析：Python3 推荐 super().__init__(参数)，不需要手动传 self。

第 7 题选择题

多继承中，如果多个父类有同名方法，排查调用顺序应查看？

A 类名.path()

B 类名.mro()

C 类名.route()

D 类名.order()

✓ 正确

解析：MRO（Method Resolution Order）可用 类名.mro() 或 类名.__mro__ 查看。不要靠感觉猜测。

第 8 题选择题

Python 中常说的"鸭子类型"强调的是？

A 对象必须来自同一个父类

B 只要对象有需要的方法，就可以被调用

C 必须先写接口文件

D 变量必须提前声明类型

✓ 正确

解析：鸭子类型核心：「如果它走路像鸭子，叫起来像鸭子，那它就是鸭子」。不强制继承关系，只关心对象有没有需要的方法。

第 9 题选择题

类方法需要使用的装饰器是？

A @staticmethod

B @classmethod

C @propertyonly

D @selfmethod

✓ 正确

解析：类方法使用 @classmethod 装饰器，第一个参数约定为 cls。

第 10 题选择题

静态方法的特点是？

A 必须使用 self

B 必须使用 cls

C 通常不依赖实例属性，也不依赖类属性

D 只能通过对象调用，不能通过类调用

✓ 正确

解析：静态方法不需要 self 或 cls，就是放在类里的普通函数。可通过对象或类名调用。

二、填空题（10 题）

第 11 题填空题

面向对象三大特性是、、。

✓ 正确

解析：三大特性：封装（数据安全）、继承（代码复用）、多态（灵活扩展）。

第 12 题填空题

私有属性通常在属性名前加。

✓ 正确

解析：答案为 __（双下划线）。如 self.__balance = 0。

第 13 题填空题

如果想在类外安全读取私有属性，通常可以提供方法。

✓ 正确

解析：答案为 get_xx()（如 get_balance()）。通过 getter 方法安全读取私有属性。

第 14 题填空题

如果想在类外安全修改私有属性，通常可以提供方法，并在方法中做校验。

✓ 正确

解析：答案为 set_xx()。在 setter 中校验类型和范围，防止非法数据。

第 15 题填空题

子类继承父类的格式是：class 子类名():

✓ 正确

解析：答案为「父类名」。括号中写要继承的父类名称。

第 16 题填空题

子类重新定义父类同名方法，叫方法。

✓ 正确

解析：答案为「重写」（Override）。调用时优先执行子类版本。

第 17 题填空题

super().__init__(name, hp) 调用的是类的初始化方法。

✓ 正确

解析：答案为「父」。super() 代表当前类的父类。

第 18 题填空题

多继承中查看方法解析顺序的两种写法是 类名.mro() 和 类名.。

✓ 正确

解析：答案为 __mro__。类名.mro() 返回列表，类名.__mro__ 返回元组。

第 19 题填空题

类方法需要装饰器，第一个参数通常写作 cls。

✓ 正确

解析：答案为 @classmethod。类方法第一个参数 cls 代表类本身。

第 20 题填空题

静态方法需要装饰器，通常不需要写 self 或 cls。

✓ 正确

解析：答案为 @staticmethod。静态方法不依赖实例或类属性。

三、简答题（10 题）

第 21 题简答题

什么是封装？封装有什么好处？

查看参考答案 ▼

✓ 正确

参考答案：封装是把属性和方法组织到类里，并控制外部访问方式。好处是让代码结构更清晰，重要数据更安全（私有属性不被外部随意修改），外部使用更简单（通过公共方法调用）。

第 22 题简答题

私有属性是不是意味着外部完全不能使用这个数据？为什么？

查看参考答案 ▼

不是。私有属性只是外部不应该直接访问，但可以通过类提供的公共方法（如 get_balance()）间接使用。

✓ 正确

参考答案：不是。私有属性只是外部不应该直接访问，但可以通过类提供的公共方法（如 get_balance()）间接使用。

第 23 题简答题

为什么 set_xx() 方法中通常要做数据校验？

查看参考答案 ▼

因为直接修改可能产生非法数据（负数余额、错误年龄）。set_xx() 可以统一做类型检查、范围校验，在修改前拦截不合理数据。

✓ 正确

参考答案：因为直接修改可能产生非法数据（负数余额、错误年龄）。set_xx() 可以统一做类型检查、范围校验，在修改前拦截不合理数据。

第 24 题简答题

什么是继承？继承的主要好处是什么？

查看参考答案 ▼

✓ 正确

参考答案：继承是子类自动获得父类已有属性和方法的机制。主要好处是减少重复代码，提高复用性。

第 25 题简答题

子类继承父类后，是否只能使用父类已有功能？为什么？

查看参考答案 ▼

✓ 正确

参考答案：不是。子类可以：①使用父类已有功能（继承）；②新增自己的方法（扩展）；③重写父类方法（覆盖）。

第 26 题简答题

什么是方法重写？什么时候需要方法重写？

查看参考答案 ▼

✓ 正确

参考答案：方法重写是子类重新定义父类同名方法。当父类方法不能满足子类需求时（比如需要不同的输出格式），就需要重写。

第 27 题简答题

super() 的作用是什么？常见使用场景是什么？

查看参考答案 ▼

super() 用于在子类中调用父类方法。最常见场景：子类重写 __init__ 后，用 super().__init__() 复用父类初始化逻辑。

✓ 正确

参考答案：super() 用于在子类中调用父类方法。最常见场景：子类重写 __init__ 后，用 super().__init__() 复用父类初始化逻辑。

第 28 题简答题

多继承出现同名方法冲突时，为什么不能靠猜？

查看参考答案 ▼

因为多继承的查找顺序由 MRO 决定，不同继承顺序会影响结果。应使用 类名.mro() 查看真实的调用顺序。

✓ 正确

参考答案：因为多继承的查找顺序由 MRO 决定，不同继承顺序会影响结果。应使用 类名.mro() 查看真实的调用顺序。

第 29 题简答题

什么是多态？多态有什么好处？

查看参考答案 ▼

✓ 正确

参考答案：多态是同一个调用入口，传入不同对象，表现出不同结果。好处：调用统一，减少 if/else 分支判断，方便扩展新类型。

第 30 题简答题

如何判断一个方法应该写成成员方法、类方法还是静态方法？

查看参考答案 ▼

✓ 正确

参考答案：口诀：需要对象数据（self）→成员方法；需要类数据（cls）→类方法；都不需要→静态方法。

四、代码实战（8 题）

第 31 题代码实战

私有属性与公共接口 — 定义 Wallet 类

使用 __init__ 初始化用户名 username 和私有余额 __balance
定义 get_balance() 方法返回当前余额
定义 deposit(money) 方法，存钱金额必须大于 0
定义 pay(money) 方法，付款金额必须大于 0 且不能超过余额
创建对象并测试存钱、付款、余额不足三种情况

查看参考答案 ▼

class Wallet:
    def __init__(self, username, balance):
        self.username = username
        self.__balance = balance

    def get_balance(self):
        return self.__balance

    def deposit(self, money):
        if money <= 0:
            print("存钱金额必须大于0")
            return
        self.__balance += money
        print(f"存钱成功，当前余额：{self.__balance}")

    def pay(self, money):
        if money <= 0:
            print("付款金额必须大于0")
            return
        if money > self.__balance:
            print("余额不足，付款失败")
            return
        self.__balance -= money
        print(f"付款成功，当前余额：{self.__balance}")

wallet = Wallet("小明", 100)
wallet.deposit(50)
wallet.pay(30)
wallet.pay(1000)
print(wallet.get_balance())

第 32 题代码实战

单继承与子类扩展 — 定义 AiTool 和 DifyTool

定义父类 AiTool，属性 name、status；方法 enable()、show_info()
定义子类 DifyTool 继承 AiTool
DifyTool 新增方法 run_workflow()，输出"正在运行 Dify 工作流"
创建对象并测试父类方法和子类方法

查看参考答案 ▼

class AiTool:
    def __init__(self, name, status):
        self.name = name
        self.status = status

    def enable(self):
        self.status = "启用"

    def show_info(self):
        print(f"工具名称：{self.name}，状态：{self.status}")

class DifyTool(AiTool):
    def run_workflow(self):
        print("正在运行 Dify 工作流")

dify = DifyTool("客服问答工作流", "未启用")
dify.show_info()
dify.enable()
dify.show_info()
dify.run_workflow()

第 33 题代码实战

方法重写 — 在 DifyTool 中重写 show_info()

在第 32 题基础上，在 DifyTool 中重写 show_info()
子类输出信息时要体现这是"Dify 平台工具"
创建对象测试重写后的效果

查看参考答案 ▼

class AiTool:
    def __init__(self, name, status):
        self.name = name
        self.status = status

    def show_info(self):
        print(f"工具名称：{self.name}，状态：{self.status}")

class DifyTool(AiTool):
    def show_info(self):
        print(f"Dify 平台工具：{self.name}，当前状态：{self.status}")

dify = DifyTool("知识库问答", "启用")
dify.show_info()  # 调用子类重写后的版本

第 34 题代码实战

使用 super() 复用父类初始化 — 定义 ModelClient 和 OpenAIClient

父类 ModelClient：属性 model_name、base_url；方法 show_config()
子类 OpenAIClient 新增属性 api_key
子类 __init__ 中必须使用 super() 调用父类初始化
子类重写 show_config()，先调用父类方法，再补充输出 api_key 前 4 位

查看参考答案 ▼

class ModelClient:
    def __init__(self, model_name, base_url):
        self.model_name = model_name
        self.base_url = base_url

    def show_config(self):
        print(f"模型名称：{self.model_name}")
        print(f"接口地址：{self.base_url}")

class OpenAIClient(ModelClient):
    def __init__(self, model_name, base_url, api_key):
        super().__init__(model_name, base_url)
        self.api_key = api_key

    def show_config(self):
        super().show_config()
        print(f"密钥前4位：{self.api_key[:4]}")

client = OpenAIClient("gpt-4.1", "https://api.openai.com", "sk-123456789")
client.show_config()

第 35 题代码实战

多态：统一运行不同工具 — 定义三个 Runner 类和统一调用函数

定义 DifyRunner、OpenAIRunner、LocalRunner，每个类都有 run() 方法
定义函数 start_runner(runner)，内部统一调用 runner.run()
分别传入三个不同对象，观察同一个函数表现出不同结果

查看参考答案 ▼

class DifyRunner:
    def run(self):
        print("DifyRunner：运行 Dify 工作流")

class OpenAIRunner:
    def run(self):
        print("OpenAIRunner：调用 OpenAI 模型")

class LocalRunner:
    def run(self):
        print("LocalRunner：运行本地模型")

def start_runner(runner):
    runner.run()  # 多态：不关心类型，只要有 run 方法就能调用

start_runner(DifyRunner())
start_runner(OpenAIRunner())
start_runner(LocalRunner())

第 36 题代码实战

类属性、类方法、静态方法 — 定义 Task 类

类属性 total_count，统计创建了多少个任务对象
实例属性 title，保存任务标题
成员方法 finish()，输出"某任务已完成"
类方法 show_total_count()，输出任务总数
静态方法 show_rule()，输出任务规则说明
创建多个对象并测试三种方法

查看参考答案 ▼

class Task:
    total_count = 0  # 类属性：全类共享

    def __init__(self, title):
        self.title = title
        Task.total_count += 1  # 通过类名修改类属性

    def finish(self):  # 成员方法：用 self
        print(f"任务《{self.title}》已完成")

    @classmethod
    def show_total_count(cls):  # 类方法：用 cls
        print(f"当前任务总数：{cls.total_count}")

    @staticmethod
    def show_rule():  # 静态方法：不用 self/cls
        print("任务规则：创建任务后，完成时调用 finish 方法")

Task.show_rule()
task1 = Task("复习继承")
task2 = Task("完成作业")
task1.finish()
task2.finish()
Task.show_total_count()

第 37 题代码实战

综合案例：AI 工具管理中心

定义父类 BaseTool，包含工具名 name、私有状态 __enabled
提供 enable()、disable()、is_enabled() 方法
定义 DifyTool 和 OpenAITool 继承 BaseTool，各自实现 run()
定义统一函数 run_tool(tool)：已启用则调用 tool.run()，否则提示未启用
创建两个工具对象，分别测试启用前和启用后的运行效果

查看参考答案 ▼

class BaseTool:
    def __init__(self, name):
        self.name = name
        self.__enabled = False  # 私有状态

    def enable(self):
        self.__enabled = True
        print(f"{self.name} 已启用")

    def disable(self):
        self.__enabled = False
        print(f"{self.name} 已禁用")

    def is_enabled(self):
        return self.__enabled

class DifyTool(BaseTool):
    def run(self):
        print(f"{self.name} 正在运行 Dify 工作流")

class OpenAITool(BaseTool):
    def run(self):
        print(f"{self.name} 正在调用 OpenAI 模型")

def run_tool(tool):
    if not tool.is_enabled():
        print(f"{tool.name} 未启用，不能运行")
        return
    tool.run()  # 多态调用

dify = DifyTool("客服知识库")
openai_tool = OpenAITool("文本生成模型")

run_tool(dify)       # 未启用，被拦截
dify.enable()
run_tool(dify)       # 启用后正常运行

openai_tool.enable()
run_tool(openai_tool)

第 38 题代码实战

综合案例：课程学习系统

定义 Course 类，类属性 total_learning_minutes 统计全班累计学习分钟数
实例属性：课程名 name、学生名 student_name
成员方法 learn(minutes)：某学生学习指定分钟数，并累加到全班总学习时长
类方法 show_total_minutes()：输出全班总学习分钟数
静态方法 show_rule()：输出学习规则
创建至少两个课程对象，测试学习和总时长统计

查看参考答案 ▼

class Course:
    total_learning_minutes = 0  # 类属性：全班总时长

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

    def learn(self, minutes):  # 成员方法
        if minutes <= 0:
            print("学习分钟数必须大于0")
            return
        print(f"{self.student_name} 学习《{self.name}》{minutes}分钟")
        Course.total_learning_minutes += minutes

    @classmethod
    def show_total_minutes(cls):  # 类方法
        print(f"全班累计学习时长：{cls.total_learning_minutes}分钟")

    @staticmethod
    def show_rule():  # 静态方法
        print("学习规则：每次学习后，请记录真实学习分钟数")

Course.show_rule()
course1 = Course("面向对象高级", "小明")
course2 = Course("面向对象高级", "小红")
course1.learn(30)
course2.learn(45)
Course.show_total_minutes()  # → 75分钟

Python 练习 002

做题记录 清空记录

答题详情

做题记录