🌙
交互式练习

LLM 练习 001

38 道题 · 选择题 + 填空题 + 简答题 + 代码实战 · 即时反馈 · 记录保存
← 返回主页
客观题
0/20
主观题
0/18
做题记录

做题记录

    暂无记录

    答题详情

    一、单选题(10 题)
    第 1 题单选题
    关于"类"和"对象"的关系,正确的是( )。
    A 类是具体存在的对象,对象是抽象模板
    B 类是抽象模板,对象是由类创建出来的具体实例
    C 类和对象完全没有关系
    D 对象只能有一个,类可以有很多个
    第 2 题单选题
    在 Python 中,定义类使用的关键字是( )。
    A `def`
    B `class`
    C `object`
    D `self`
    第 3 题单选题
    如果已经定义了 Student 类,创建对象的正确写法是( )。
    A `stu = Student()`
    B `stu = new Student()`
    C `stu = class Student()`
    D `stu = Student[]`
    第 4 题单选题
    关于 self 的说法,正确的是( )。
    A `self` 指向调用当前方法的对象
    B `self` 固定指向类本身
    C `self` 只能在类外部使用
    D `self` 是字符串类型
    第 5 题单选题
    __init__ 方法通常在什么时候自动调用?( )
    A 每次打印对象时
    B 每次删除对象时
    C 创建对象时
    D 导入模块时
    第 6 题单选题
    __init__ 方法最主要的作用是( )。
    A 给对象初始化属性
    B 删除对象属性
    C 强制退出程序
    D 复制一个对象
    第 7 题单选题
    在类内部访问当前对象的属性,通常使用( )。
    A `class.属性名`
    B `self.属性名`
    C `对象->属性名`
    D `属性名::self`
    第 8 题单选题
    关于封装,下列说法正确的是( )。
    A 封装就是把属性和方法组织到类中,并控制访问方式
    B 封装意味着所有代码都不能访问属性
    C 封装会让代码完全不能复用
    D 封装只和函数有关,和类无关
    第 9 题单选题
    Python 中,通常把属性名前加双下划线 __ 表示( )。
    A 普通属性
    B 私有属性
    C 全局变量
    D 模块名
    第 10 题单选题
    print(对象) 时,如果想输出一段可读的对象信息,通常需要重写( )。
    A `__init__`
    B `__str__`
    C `__del__`
    D `__add__`
    二、填空题(10 题)
    第 11 题填空题
    面向对象编程中,类可以理解为(),对象可以理解为()。
    第 12 题填空题
    定义类时推荐使用()命名法,例如 StudentInfo
    第 13 题填空题
    创建对象的语法通常是:对象名 = ()()
    第 14 题填空题
    self 表示()。
    第 15 题填空题
    __init__ 方法用于初始化对象的()。
    第 16 题填空题
    在类内部定义方法时,第一个参数通常写成()。
    第 17 题填空题
    print(对象) 时,如果想显示自定义信息,可以重写()方法。
    第 18 题填空题
    封装的好处之一是可以让属性和方法组织更清晰,提高代码的()。
    第 19 题填空题
    私有属性通常在属性名前加()。
    第 20 题填空题
    如果想安全读取私有属性,通常可以在类中提供()方法。
    三、简答题(10 题)
    第 21 题简答题
    请用自己的话说明什么是类,什么是对象。
    查看参考答案 ▼
    类是对一类事物的抽象描述,比如学生类、手机类;对象是根据类创建出来的具体个体,比如张三这个学生、小米手机这个对象。
    第 22 题简答题
    为什么说"先有类,再有对象"?
    查看参考答案 ▼
    类相当于设计图,对象相当于根据设计图造出来的具体东西,所以通常先定义类,再根据类创建对象。
    第 23 题简答题
    self 的作用是什么?请举一个两个对象调用同一个方法的例子。
    查看参考答案 ▼
    self 表示调用当前方法的对象。比如 stu1.introduce() 时,self 指向 stu1stu2.introduce() 时,self 指向 stu2
    第 24 题简答题
    为什么推荐在 __init__ 中统一初始化对象属性?
    查看参考答案 ▼
    __init__ 中统一初始化属性,可以保证每个对象创建出来时都有相同的属性结构,避免类外部随意添加属性导致代码混乱。
    第 25 题简答题
    __init__ 和普通方法有什么区别?
    查看参考答案 ▼
    __init__ 会在创建对象时自动调用,主要用于初始化属性;普通方法需要通过对象主动调用。
    第 26 题简答题
    __str__ 的作用是什么?如果不写 __str__,直接打印对象通常会看到什么?
    查看参考答案 ▼
    __str__ 用于自定义 print(对象) 时显示的内容。如果不写,通常会看到对象类型和内存地址,不方便阅读。
    第 27 题简答题
    什么是封装?封装有什么好处?
    查看参考答案 ▼
    封装是把属性和方法组织到类中,并通过方法控制属性访问。好处是结构清晰、安全性更好、维护更方便。
    第 28 题简答题
    私有属性为什么不能随便从类外部直接修改?
    查看参考答案 ▼
    私有属性通常代表不希望外部随意修改的数据,如果类外部可以随便改,可能导致对象状态不合法,比如余额变成负数、分数超过 100。
    第 29 题简答题
    "类外部临时给对象添加属性"为什么不推荐?
    查看参考答案 ▼
    类外部临时添加属性会导致不同对象属性结构不一致,后期维护和排错会更困难。
    第 30 题简答题
    面向对象相比面向过程,在"多个学生、多个商品、多个 AI 工具账号"这种场景下有什么优势?
    查看参考答案 ▼
    面向对象可以把每个学生、商品、AI 工具账号都封装成独立对象,每个对象保存自己的属性和状态,扩展多个对象时更清晰、更容易维护。
    四、代码实战(8 题)
    第 31 题代码实战
    定义学生类
    定义 Student 类,要求:
    1. 使用 __init__ 初始化 nameage
    2. 定义 introduce() 方法,输出学生姓名和年龄。
    3. 创建两个学生对象,分别调用 introduce()
    查看参考答案 ▼
    class Student: def __init__(self, name, age): # self.name 表示当前对象自己的 name 属性。 # 外部传入的 name 会保存到当前对象中。 self.name = name # self.age 表示当前对象自己的 age 属性。 # 每个对象都有自己独立的 age。 self.age = age def introduce(self): # self 指向调用 introduce 方法的对象。 # 如果 stu1 调用,self 就是 stu1。 # 如果 stu2 调用,self 就是 stu2。 print(f"大家好,我叫{self.name},今年{self.age}岁。") # 创建第一个学生对象。 stu1 = Student("张三", 18) # 创建第二个学生对象。 stu2 = Student("李四", 20) # 两个对象分别调用同一个方法,但 self 指向不同对象。 stu1.introduce() stu2.introduce()
    第 32 题代码实战
    定义手机类并打印对象信息
    定义 Phone 类,要求:
    1. 使用 __init__ 初始化 brandprice
    2. 定义 call() 方法,输出"某品牌手机正在打电话"。
    3. 定义 __str__() 方法,打印对象时显示品牌和价格。
    4. 创建两个手机对象并测试。
    查看参考答案 ▼
    class Phone: def __init__(self, brand, price): # 初始化手机品牌。 self.brand = brand # 初始化手机价格。 self.price = price def call(self): # 使用对象自己的 brand 属性输出信息。 print(f"{self.brand} 手机正在打电话。") def __str__(self): # 当 print(对象) 时,会自动调用 __str__。 # 返回值必须是字符串。 return f"手机品牌:{self.brand},价格:{self.price} 元" phone1 = Phone("华为", 4999) phone2 = Phone("小米", 2999) # print 对象时,会触发 __str__,显示更友好的对象信息。 print(phone1) print(phone2) # 调用对象方法。 phone1.call() phone2.call()
    第 33 题代码实战
    封装账号余额
    定义 Account 类,要求:
    1. 使用 __init__ 初始化用户名和私有余额 __balance
    2. 定义 get_balance() 方法,返回余额。
    3. 定义 deposit(amount) 方法,充值金额。
    4. 创建对象并测试充值前后余额。
    查看参考答案 ▼
    class Account: def __init__(self, username, balance): # 普通属性:用户名可以正常访问。 self.username = username # 私有属性:余额不希望类外部随意修改。 # 加双下划线后,类外部不能直接通过 对象.__balance 访问。 self.__balance = balance def get_balance(self): # 提供一个公开方法,用来安全读取私有余额。 return self.__balance def deposit(self, amount): # 充值前先判断金额是否合法。 if amount <= 0: print("充值金额必须大于 0") return # 修改私有属性时,在类内部完成。 self.__balance += amount print(f"{self.username} 充值 {amount} 元成功,当前余额:{self.__balance} 元") account = Account("张三", 100) # 通过 get_balance 安全读取余额。 print("充值前余额:", account.get_balance()) # 调用充值方法。 account.deposit(50) # 再次查看余额。 print("充值后余额:", account.get_balance())
    第 34 题代码实战
    减肥案例升级版
    定义 Person 类,要求:
    1. 属性:nameweight
    2. run():每次跑步体重减少 0.5kg
    3. eat():每次吃饭体重增加 1kg
    4. 创建两个对象,验证两个人体重互不影响。
    查看参考答案 ▼
    class Person: def __init__(self, name, weight): # 姓名属性。 self.name = name # 体重属性。 # 每个对象都有自己的 weight,互不影响。 self.weight = weight def run(self): # 跑步后,当前对象自己的体重减少 0.5。 self.weight -= 0.5 print(f"{self.name} 跑步后体重为:{self.weight}kg") def eat(self): # 吃饭后,当前对象自己的体重增加 1。 self.weight += 1 print(f"{self.name} 吃饭后体重为:{self.weight}kg") xiaoming = Person("小明", 80) xiaohong = Person("小红", 55) # 小明的行为只影响小明自己的体重。 xiaoming.run() xiaoming.eat() # 小红的行为只影响小红自己的体重。 xiaohong.run() # 打印结果可以看到两个对象的数据互不影响。 print("小明最终体重:", xiaoming.weight) print("小红最终体重:", xiaohong.weight)
    第 35 题代码实战
    AI 工具调用额度
    定义 AiToolAccount 类,模拟一个 AI 工具账号,要求:
    1. 属性:username、私有属性 __quota 表示剩余调用次数。
    2. call_ai():每调用一次,额度减少 1。
    3. 如果额度不足,提示"额度不足,请充值"。
    4. recharge(count):增加调用额度。
    5. get_quota():查看剩余额度。
    查看参考答案 ▼
    class AiToolAccount: def __init__(self, username, quota): # 用户名,表示当前 AI 工具账号是谁的。 self.username = username # 私有属性:剩余调用次数。 # 不建议外部直接修改,避免额度被随意改成负数或异常值。 self.__quota = quota def call_ai(self): # 如果额度不足,不能继续调用。 if self.__quota <= 0: print("额度不足,请充值") return # 每调用一次 AI,额度减少 1。 self.__quota -= 1 print(f"{self.username} 调用 AI 成功,剩余额度:{self.__quota}") def recharge(self, count): # 充值次数必须大于 0。 if count <= 0: print("充值次数必须大于 0") return # 在类内部修改私有属性。 self.__quota += count print(f"充值成功,当前额度:{self.__quota}") def get_quota(self): # 提供公开方法查看私有额度。 return self.__quota account = AiToolAccount("关同学", 2) account.call_ai() account.call_ai() account.call_ai() account.recharge(3) print("当前剩余额度:", account.get_quota())
    第 36 题代码实战
    烤地瓜增加重置功能
    定义 SweetPotato 类,要求:
    1. 属性:cook_timecook_statecondiments
    2. cook(time):累计烤制时间,并根据总时间更新状态。
    3. add_condiment(name):添加调料。
    4. reset():把时间恢复为 0,状态恢复为"生的",调料清空。
    5. 定义 __str__() 返回当前状态。
    查看参考答案 ▼
    class SweetPotato: def __init__(self): # 烤制总时间,初始为 0。 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 < 7: self.cook_state = "半生不熟" elif 7 <= self.cook_time <= 12: self.cook_state = "熟了" else: self.cook_state = "糊了" def add_condiment(self, name): # append 用来给列表追加一个调料。 self.condiments.append(name) def reset(self): # 重置时间。 self.cook_time = 0 # 重置状态。 self.cook_state = "生的" # 清空调料。 self.condiments = [] def __str__(self): # 返回对象当前状态,方便 print(对象)。 return f"烤制时间:{self.cook_time}分钟,状态:{self.cook_state},调料:{self.condiments}" potato = SweetPotato() potato.cook(5) potato.add_condiment("辣椒面") print(potato) potato.reset() print("重置后:", potato)
    第 37 题代码实战
    综合案例 1:学生成绩管理
    定义 ScoreStudent 类,要求:
    1. 属性:name、私有属性 __score
    2. 分数必须在 0-100 之间。
    3. set_score(score):修改分数,非法分数不允许修改。
    4. get_score():返回当前分数。
    5. is_pass():判断是否及格。
    6. __str__():打印对象时显示学生姓名、分数、是否及格。
    7. 创建至少两个学生对象测试。
    查看参考答案 ▼
    class ScoreStudent: def __init__(self, name, score): # 学生姓名。 self.name = name # 私有分数属性。 # 为了保证分数始终合法,不让外部随便改。 self.__score = 0 # 初始化时也通过 set_score 进行校验。 self.set_score(score) def set_score(self, score): # 分数必须在 0 到 100 之间。 if 0 <= score <= 100: self.__score = score else: print("分数必须在 0-100 之间,本次修改无效") def get_score(self): # 通过公开方法读取私有分数。 return self.__score def is_pass(self): # 分数大于等于 60 表示及格。 return self.__score >= 60 def __str__(self): # 根据 is_pass 的结果生成文字。 result = "及格" if self.is_pass() else "不及格" return f"学生:{self.name},分数:{self.__score},结果:{result}" stu1 = ScoreStudent("张三", 88) stu2 = ScoreStudent("李四", 50) print(stu1) print(stu2) # 尝试设置非法分数。 stu1.set_score(150) print(stu1) # 设置合法分数。 stu2.set_score(70) print(stu2)
    第 38 题代码实战
    综合案例 2:AI 服务套餐账号
    定义 AiServicePlan 类,模拟一个 AI 服务套餐账号,要求:
    1. 属性:usernameplan_name、私有属性 __remain_tokens
    2. use_tokens(count):使用指定 token 数。
    3. 如果 token 足够,扣减并提示剩余 token。
    4. 如果 token 不足,提示"不足以完成本次调用"。
    5. upgrade_plan(new_plan, add_tokens):升级套餐并增加 token。
    6. get_remain_tokens():查看剩余 token。
    7. __str__():返回账号、套餐、剩余 token 信息。
    查看参考答案 ▼
    class AiServicePlan: def __init__(self, username, plan_name, remain_tokens): # 用户名。 self.username = username # 套餐名称,例如 basic、pro、team。 self.plan_name = plan_name # 私有属性:剩余 token 数。 # token 是大模型调用中常见的计量单位。 self.__remain_tokens = remain_tokens def use_tokens(self, count): # 使用 token 数必须大于 0。 if count <= 0: print("使用 token 数必须大于 0") return # 如果剩余 token 不够,则不能扣减。 if count > self.__remain_tokens: print("不足以完成本次调用,请升级套餐或充值 token") return # 扣减 token。 self.__remain_tokens -= count print(f"本次使用 {count} token,剩余 {self.__remain_tokens} token") def upgrade_plan(self, new_plan, add_tokens): # 升级套餐名称。 self.plan_name = new_plan # 增加 token 数。 self.__remain_tokens += add_tokens print(f"套餐升级为 {self.plan_name},增加 {add_tokens} token") def get_remain_tokens(self): # 提供公开方法查看私有 token。 return self.__remain_tokens def __str__(self): # 返回账号当前信息。 return f"用户:{self.username},套餐:{self.plan_name},剩余 token:{self.__remain_tokens}" plan = AiServicePlan("小明", "basic", 1000) print(plan) # 第一次调用,token 足够。 plan.use_tokens(300) # 第二次调用,token 不足。 plan.use_tokens(900) # 升级套餐并增加 token。 plan.upgrade_plan("pro", 3000) # 再次调用。 plan.use_tokens(900) print(plan) print("剩余 token:", plan.get_remain_tokens())