面向对象的题目

定义简单的类

需求：定义一个 Student 类，包含以下内容：

属性：姓名（name）、年龄（age）、成绩（score，默认为 0）

方法：
get_info()：返回学生信息的字符串，格式为 “姓名：xxx，年龄：xxx，成绩：xxx”
update_score(new_score)：修改学生成绩（要求新成绩必须是 0-100 之间的整数，否则不修改）

class Student:
    def __init__(self,name,age,score=0):
        self.name=name
        self.age=age
        self.score=score
    # 返回学生的所有信息
    def get_info(self):
        return f"姓名:{self.name},年龄:{self.age},成绩:{self.score}"
    # 修改学生的成绩
    def update_score(self,new_score):
        self.score=new_score  # 修改成绩，修改实例属性
        if not isinstance(new_score,int):
            print("错误，成绩必须是整数！")
            return
        if new_score >=0 and new_score<=100:
            self.score=new_score
            print(f"成绩修改成功,当前成绩为{self.score}")
        else:
            print("错误，成绩必须在0到100之间")


if __name__ == '__main__':
    # 创建学生实例
    stu1=Student("小米",20)
    print("初始信息,",stu1.get_info())

    # 修改成绩
    stu1.update_score(85)
    print("修改后信息",stu1.get_info())

# 输出信息
初始信息, 姓名:小米,年龄:20,成绩:0
成绩修改成功,当前成绩为85
修改后信息 姓名:小米,年龄:20,成绩:85

封装练习

需求：定义一个 BankAccount 类，模拟银行账户：

私有属性：账户余额（__balance，初始值为 0）

方法：
deposit(amount)：存款（amount 必须为正数，否则提示 “存款金额无效”）
withdraw(amount)：取款（amount 必须为正数且不超过余额，否则提示 “取款失败”）
get_balance()：返回当前余额（通过此方法对外暴露余额，不能直接访问私有属性）

class BankAcoount:
    def __init__(self,balacne=0):
        # 定义一个私有属性，账户余额
        self.__balance=balacne

    # 存款
    def deposit(self,amount):
        if amount >0:
            self.__balance=amount
            print(f"存款成功，余额为{self.__balance}")
        else:
            print("存款金额无效")

    # 取款
    def withdraw(self,amount):
        # 输入正数
        if amount<0:
            print("存款必须是正数")
            return
        # 取款金额小于存款
        if amount > self.__balance:
            print("取款大于存款，取款失败")
            return

        # 校验成功后，取款
        self.__balance-=amount
        print(f"取款成功,{amount}")


    # 查看余额
    def get_balance(self):
        print(f"余额{self.__balance}")

# 主函数，从这个里面执行
if __name__ == '__main__':
    w1=BankAcoount()
    # 存1000
    w1.deposit(1000)

    # 取500
    w1.withdraw(500)

    # 查看当前余额
    w1.get_balance()


# 输出信息
存款成功，余额为1000
取款成功,500
余额500

继承练习

需求：基于以下场景设计类：
父类 Vehicle（交通工具）：
属性：品牌（brand）、颜色（color）
方法：run()，打印 “xxx（品牌）的 xxx（颜色）车在行驶”

子类 Car（小汽车）继承 Vehicle：
新增属性：座位数（seats）
重写 run() 方法，打印 “xxx（品牌）的 xxx（颜色）小汽车，有 xxx 个座位，正在公路上行驶”

子类 Bicycle（自行车）继承 Vehicle：
新增属性：是否电动（is_electric，布尔值）
重写 run() 方法，打印 “xxx（品牌）的 xxx（颜色）自行车，xxx 电动，正在骑行”（如果是电动则显示 “是”，否则显示 “不是”）

class Vehcie():
    def __init__(self,brand,color):
        # 属性就是定义模版的，行为等操作写在方法上面
        self.brand=brand
        self.color=color

    def run(self):
        return f"{self.brand}的{self.color}车在行驶"

class Car(Vehcie):
    def __init__(self,brand,color,seats):
        super().__init__(brand, color)  # 继承父类中__init__初始化方法，这样的话就不需要再次重新定义brand,color这些了
        self.seates=seats  # 派生了一个新的属性

    # 重写这个run方法就是，当父类的run方法不能够满足的情况下，使用的
    def run(self):
        return f"{self.brand}的{self.color}小汽车,有{self.seates}个座位，正在公路上行驶"

class Bycler(Vehcie):
    def __init__(self,brand,color,is_electric):
        super().__init__(brand,color)
        self.is_electric=is_electric

    def run(self):
        if self.is_electric == "True":
            self.is_electric = "是"
        else:
            self.is_electric = "不是"
        return f"{self.brand}的{self.color}自行车,{self.is_electric}电动,正在骑行"

if __name__ == '__main__':
    c1=Car("li","绿色",20)
    print(c1.run())
    b1=Bycler("pp","蓝色","True")
    print(b1.run())
    b1=Bycler("pp","蓝色","False")
    print(b1.run())

多态练习

需求：设计一个简单的 “形状计算” 程序：
父类 Shape（形状）：
方法：get_area()，返回 0（作为基类，无具体实现）

子类 Circle（圆形）继承 Shape：
属性：半径（radius）
重写 get_area()：计算圆的面积（公式：π× 半径 ²，π 取 3.14）

子类 Rectangle（矩形）继承 Shape：
属性：长（length）、宽（width）
重写 get_area()：计算矩形的面积（公式：长 × 宽）
最后定义一个函数 print_area(shape)，接收一个 Shape 子类对象，打印 “该形状的面积是：xxx”

class Shape():
    def get_area(self):
        return 0

class Circle(Shape):
    def __init__(self,radius):
        self.radius=radius
    def get_area(self):
        area= self.radius*self.radius*3.14
        return f"{area}"

class Rectangle(Shape):
    def __init__(self,h,w):
        self.w=w
        self.h=h
    def get_area(self):
        area = self.w*self.h
        return f"{area}"

# 这个就相当于是一个接口
def print_area(shape):
    print(f"该形状的面积是{shape.get_area()}")

# 多态就是同一个方法，不同的对象调用则会呈现不同的结果
# 需要定义一个函数，形参是对象，然后调用函数即可实现
if __name__ == '__main__':

    c1=Circle(2)
    r1=Rectangle(1,2)
    print_area(c1)
    print_area(r1)

类的交互

• 需求：模拟 “图书馆借阅” 场景：

  • Book 类：

    • 属性：书名（title）、作者（author）、是否被借出（is_borrowed，默认为 False）

    • 方法：get_status()，返回 “可借阅” 或 “已借出”

  • Reader 类：

    • 属性：姓名（name）、借阅的书籍列表（borrowed_books，初始为空列表）

    • 方法：
      - borrow_book(book)：借阅书籍（如果书籍未被借出，则添加到 borrowed_books，并修改书籍的 is_borrowed 为 True；否则提示 “该书已被借出”）

    • return_book(book)：归还书籍（如果书籍在 borrowed_books 中，则移除并修改 is_borrowed 为 False；否则提示 “未借阅此书”）

• 测试：创建 2 本书、1 个读者，模拟借阅和归还操作，并打印结果

# 难点就是
- reader和book之间交互关系

- 一个读者可以借阅多本书，但是同一本书只能在同一时间被一个读者借阅

- 这种一对多的情况，需要通过列表和状态标志

- 理解将对象作为参数传递的概念

class Book():
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_borrowed = False  # 默认是没有借出去的

    def get_status(self):
        # 判断是否可以借阅
        if self.is_borrowed == False:
            return "可以借阅"
        else:
            return "已借出"


class Reader():
    def __init__(self, name):
        self.name = name  # 读者的姓名
        self.borrowed_books = []

    # 借阅书籍
    def borrow_book(self, book):  # 这个传入的是对象
        # 如果是true的话，就表示这个书已经被借出去了
        if book.is_borrowed:
            print(f"{book.title}已经被借出去了")
            return
        # 为false的话，就添加到这个列表里面去,直接添加了一个对象,比较的时候比较的是id
        self.borrowed_books.append(book)
        book.is_borrowed = True  # 表示这本书被借出去了
        print(f"{self.name}成功借阅{book.title}")

    # 归还书籍
    def return_book(self,book):
        # 判断书籍是否存在
        # 不在这个列表，就表示没有被借阅 
        if book not in self.borrowed_books:   # 比较的对象的id,id不在这个列表的话，就没有借过这本书
            print(f"{self.name}未借阅{book.title},归还失败")
            return

        # 在这列表中，就表示借阅了,现在要归还了

        self.borrowed_books.remove(book)
        book.is_borrowed=False  # 表示这本书可以借阅了
        print(f"{self.name}成功归还了{book.title}")

    # 查看作者借阅了哪些书籍
    def show_borrowed_books(self):
        if not self.borrowed_books:
            return f"{self.name} 当前没有借阅任何书籍"

        # 判断借书的人的  借阅的情况
        book_title=[]
        for book in self.borrowed_books:
            book_title.append(book.title)
        return  f"{self.name} 当前借阅的书籍为{','.join(book_title)}"




if __name__ == '__main__':
    # 创建了2本书的实例
    book1 = Book("python编程", "qq")
    book2 = Book("算法", "pp")

    # 创建作者
    r = Reader("wq")
    print("书籍1:", book1.get_status())
    print("书籍2:", book2.get_status())

    # 借阅书籍1
    r.borrow_book(book1)
    print("书籍1的状态:",book1.get_status())
    r.borrow_book(book2)
    print("书籍2的状态",book2.get_status())

    # 再次借阅书籍1
    r.borrow_book(book1)
    print("书籍1状态",book1.get_status())  # 会失败的，因为书籍都被借出去了

    # 查看借阅状态
    print("借阅状态",r.show_borrowed_books())