python中面向对象练习题五（难题）

1.第一题

假设我们正在开发一个银行账户管理系统，其中有一个账户类 Account，每个账户具有以下属性和功能：

属性：

• 账号（account_number）
• 持有人姓名（owner）
• 余额（balance）

功能：

• 存款（deposit）
• 取款（withdraw）
• 查询余额（get_balance）

现在，我们希望实现一个从外部数据源加载账户信息并创建账户对象的类方法。这样，我们可以通过类方法来统一处理账户对象的创建过程，并确保创建的账户对象已初始化。

class Account:  
    def __init__(self, account_number, owner, balance=0):  
        self.account_number = account_number  
        self.owner = owner  
        self.balance = balance  
  
    def deposit(self, amount):  
        if amount > 0:  
            self.balance += amount  
            print(f"Deposited {amount}. New balance is {self.balance}.")  
        else:  
            print("Deposit amount must be positive.")  
  
    def withdraw(self, amount):  
        if amount > 0 and amount <= self.balance:  
            self.balance -= amount  
            print(f"Withdrawn {amount}. New balance is {self.balance}.")  
        elif amount > self.balance:  
            print("Insufficient funds.")  
        else:  
            print("Withdrawal amount must be positive.")  
  
    def get_balance(self):  
        return self.balance  
  
    @classmethod  
    def from_data_source(cls, data):  
        """  
        假设 `data` 是一个包含账号、持有人姓名和余额的字典。  
        使用这些数据来创建一个新的 Account 对象。  
        """  
        account_number = data.get('account_number')  
        owner = data.get('owner')  
        balance = data.get('balance', 0)  # 如果没有提供余额，则默认为0  
  
        # 验证数据是否完整  
        if not all([account_number, owner]):  
            raise ValueError("Incomplete account data: account_number and owner are required.")  
  
        # 使用数据创建并返回一个新的 Account 对象  
        return cls(account_number, owner, balance)  
  
# 示例：使用 from_data_source 类方法从数据源创建 Account 对象  
data_from_source = {  
    'account_number': '1234567890',  
    'owner': 'John Doe',  
    'balance': 1000  
}  
  
# 创建一个新的账户对象  
new_account = Account.from_data_source(data_from_source)  
  
# 验证账户信息  
print(f"Account number: {new_account.account_number}")  
print(f"Account owner: {new_account.owner}")  
print(f"Account balance: {new_account.get_balance()}")  
  
# 存款和取款操作  
new_account.deposit(500)  
new_account.withdraw(200)

2.第二题 

在电商业务场景中，需要设计商品类、购物车类和用户类。具体描述如下：

1. 商品类（Product）：每个商品对象应具有以下属性和方法：
   • 属性：名称（name）、价格（price）、库存数量（stock）
   • 方法：获取商品名称（get_name()）、获取商品价格（get_price()）、获取商品库存数量（get_stock()）、更新商品库存数量（update_stock(quantity)）
2. 普通商品类（RegularProduct）：继承自商品类，每个普通商品对象应具有以下特有的方法：
   • 方法：购买商品（buy_product(quantity)）：根据购买的数量减少商品库存量；如果库存不足，则输出"库存不足，无法购买该商品"；否则，减少库存数量。
   • 方法：添加到购物车（add_to_cart(cart, quantity)）：将商品添加到指定购物车对象中，同时指定购买的数量。
3. 折扣商品类（DiscountProduct）：继承自商品类，每个折扣商品对象应具有以下特有的属性和方法：
   • 属性：折扣（discount）
   • 方法：购买商品（buy_product(quantity)）：根据购买的数量减少商品库存量；如果库存不足，则输出"库存不足，无法购买该商品"；否则，减少库存数量。
   • 方法：添加到购物车（add_to_cart(cart, quantity)）：将商品添加到指定购物车对象中，同时指定购买的数量。
4. 购物车类（Cart）：每个购物车对象应具有以下属性和方法：
   • 属性：商品项（items）,提示：考虑用字典进行存储
   • 方法：添加商品（add_item(product, quantity)）：将指定数量的商品添加到购物车中；如果商品已存在于购物车，则增加该商品的数量；否则，添加新的商品项。
   • 方法：删除商品（remove_item(product, quantity)）：从购物车中删除指定数量的商品；如果商品数量不足以删除，则直接删除该商品项；否则，减少商品数量。
   • 方法：查看购物车内容（view_items()）：输出购物车中的商品项及其对应的数量。
   • 方法：清空购物车（clear()）：将购物车中的商品项清空。
5. 用户类（User）：每个用户对象应具有以下属性和方法：
   • 属性：用户名（name）、购物车（cart）
   • 方法：添加商品到购物车（add_to_cart(product, quantity)）：将指定数量的商品添加到用户的购物车中。
   • 方法：查看购物车内容（view_cart()）：输出用户购物车中的商品项及其对应的数量。
   • 方法：结算订单并支付（checkout()）：根据购物车中的商品项生成订单对象，并进行支付；支付成功后，清空购物车。
6. 订单类（Order）：每个订单对象应具有以下属性和方法：
   • 属性：购物车（cart）、总价（total_price）
   • 方法：计算总价（calculate_total_price()）：根据购物车中的商品项计算订单的总价。
   • 方法：支付（pay()）：执行支付逻辑，输出支付成功信息，并显示支付金额。

请使用面向对象的思想，设计并实现这些类，并编写主程序测试上述功能。请确保代码的正确性和健壮性，并合理处理各类之间的关系。

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def get_name(self):
        return self.name

    def get_price(self):
        return self.price

    def get_stock(self):
        return self.stock

    def update_stock(self, quantity):
        self.stock += quantity


class RegularProduct(Product):
    def __init__(self, name, price, stock):
        super().__init__(name, price, stock)

    def buy_product(self, quantity):
        if self.stock < quantity:
            print("库存不足，无法购买该商品")
        else:
            self.stock -= quantity

    def add_to_cart(self, cart, quantity):
        cart.add_item(self, quantity)


class DiscountProduct(Product):
    def __init__(self, name, price, stock, discount):
        super().__init__(name, price, stock)
        self.discount = discount

    def buy_product(self, quantity):
        if self.stock < quantity:
            print("库存不足，无法购买该商品")
        else:
            self.stock -= quantity

    def add_to_cart(self, cart, quantity):
        cart.add_item(self, quantity)


class User:
    def __init__(self, name):
        self.name = name
        self.cart = Cart()

    def add_to_cart(self, product, quantity):
        self.cart.add_item(product, quantity)

    def view_cart(self):
        self.cart.view_items()

    def checkout(self):
        order = Order(self.cart)
        order.pay()
        self.cart.clear()


class Cart:
    def __init__(self):
        self.items = {}

    def add_item(self, product, quantity):
        if product in self.items:
            self.items[product] += quantity
        else:
            self.items[product] = quantity

    def remove_item(self, product, quantity):
        if product in self.items:
            if self.items[product] <= quantity:
                del self.items[product]
            else:
                self.items[product] -= quantity

    def view_items(self):
        for product, quantity in self.items.items():
            print(f"{product.get_name()} - 数量：{quantity}")

    def clear(self):
        self.items = {}


class Order:
    def __init__(self, cart):
        self.cart = cart
        self.total_price = self.calculate_total_price()

    def calculate_total_price(self):
        total_price = 0
        for product, quantity in self.cart.items.items():
            total_price += product.get_price() * quantity
        return total_price

    def pay(self):
        # 实现支付逻辑
        print(f"支付成功！支付金额：{self.total_price}")


# 创建普通商品对象和折扣商品对象
regular_product = RegularProduct("iPhone 12", 6999, 100)
discount_product = DiscountProduct("Apple Watch", 1999, 50, 0.8)

# 创建用户对象
user = User("John")

# 用户添加商品到购物车，并查看购物车
user.add_to_cart(regular_product, 2)
user.add_to_cart(discount_product, 3)
user.view_cart()

# 用户结算订单并支付
user.checkout()