如何用组合替代Python多重继承？求实现建议与示例

嘿，我完全理解你现在的困惑——从多重继承切换到组合确实需要调整一下思考方式，咱们一步步来拆解，帮你理清思路。

首先，先明确核心逻辑：原来的代码用多重继承（比如HouseRental同时继承Rental和House）来复用购买/租赁和房产类型的代码，但这种方式容易引发菱形继承、方法解析顺序（MRO）混乱等问题。而组合的思路是把Purchase和Rental作为独立的功能组件，让房产类（House/Apartment）持有这些组件的实例，而不是继承它们。

第一步：重构Purchase和Rental为独立组件 #

先把这两个类改成纯粹的功能类，不再继承任何房产相关的类，只专注处理购买或租赁的逻辑：

class Purchase:
    def __init__(self, price='', taxes=''):
        self.price = price
        self.taxes = taxes

    def display(self):
        print('Purchase Details')
        print(f'selling price: {self.price}')
        print(f'est taxes: {self.taxes}')

    @staticmethod
    def prompt_init():
        return dict(
            price=input('What is the selling price? '),
            taxes=input('What are the est taxes? ')
        )


class Rental:
    def __init__(self, furnished='', utilities='', rent=''):
        self.furnished = furnished
        self.rent = rent
        self.utilities = utilities

    def display(self):
        print('Rental Details')
        print(f'rent price: {self.rent}')
        print(f'est utilities: {self.utilities}')
        print(f'furnished: {self.furnished}')

    @staticmethod
    def prompt_init():
        return dict(
            rent=input('What is the monthly rent? '),
            utilities=input('What are the est utilities? '),
            furnished=get_valid_input('Is the property furnished? ', ('yes', 'no')),
        )

第二步：选择组合方式（两种可选方案） #

方案1：创建专门的组合类（结构清晰）

这种方式为每种房产+支付的组合创建单独的类，明确对应关系：

class HouseRental:
    def __init__(self, house_details, rental_details):
        self.house = House(**house_details)
        self.rental = Rental(**rental_details)

    def display(self):
        self.house.display()
        self.rental.display()

    @staticmethod
    def prompt_init():
        house_init = House.prompt_init()
        rental_init = Rental.prompt_init()
        return {"house_details": house_init, "rental_details": rental_init}


class ApartmentPurchase:
    def __init__(self, apartment_details, purchase_details):
        self.apartment = Apartment(**apartment_details)
        self.purchase = Purchase(**purchase_details)

    def display(self):
        self.apartment.display()
        self.purchase.display()

    @staticmethod
    def prompt_init():
        apartment_init = Apartment.prompt_init()
        purchase_init = Purchase.prompt_init()
        return {"apartment_details": apartment_init, "purchase_details": purchase_init}

# 同理实现HousePurchase和ApartmentRental类

然后更新Agent类的type_map，指向这些组合类：

class Agent:
    def __init__(self):
        self.property_list = []

    def display_properties(self):
        for property in self.property_list:
            property.display()

    type_map = {
        ('house', 'rental'): HouseRental,
        ('house', 'purchase'): HousePurchase,
        ('apartment', 'rental'): ApartmentRental,
        ('apartment', 'purchase'): ApartmentPurchase
    }

    def add_property(self):
        property_type = get_valid_input('What property? ', ('house', 'apartment'))
        payment_type = get_valid_input('What payment type? ', ('purchase', 'rental'))
        PropertyClass = self.type_map[(property_type, payment_type)]
        init_args = PropertyClass.prompt_init()
        self.property_list.append(PropertyClass(**init_args))

方案2：给房产类添加组件属性（更灵活）

这种方式不需要创建额外的组合类，而是让Property及其子类持有一个payment_component属性，动态注入购买/租赁组件：

首先修改Property类：

class Property:
    def __init__(self, square_feet='', beds='', baths='', payment_component=None, **kwargs):
        self.square_feet = square_feet
        self.num_beds = beds
        self.num_baths = baths
        self.payment_component = payment_component  # 持有支付组件

    def display(self):
        print("PROPERTY DETAILS")
        print(f'square footage: {self.square_feet}')
        print(f'bedrooms: {self.num_beds}')
        print(f'baths: {self.num_baths}')
        print()
        # 如果有支付组件，就显示其信息
        if self.payment_component:
            self.payment_component.display()

    @staticmethod
    def prompt_init():
        return dict(
            square_feet=input("Enter the square feet: "),
            beds=input("Enter number of bedrooms: "),
            baths=input("Enter number of baths: ")
        )

然后修改Agent类的add_property方法，动态组合房产类和支付组件：

class Agent:
    def __init__(self):
        self.property_list = []

    def display_properties(self):
        for property in self.property_list:
            property.display()

    # 映射房产类型和支付类型对应的类
    type_map = {
        ('house', 'rental'): (House, Rental),
        ('house', 'purchase'): (House, Purchase),
        ('apartment', 'rental'): (Apartment, Rental),
        ('apartment', 'purchase'): (Apartment, Purchase)
    }

    def add_property(self):
        property_type = get_valid_input('What property? ', ('house', 'apartment'))
        payment_type = get_valid_input('What payment type? ', ('purchase', 'rental'))
        
        # 获取对应的房产类和支付类
        PropertyCls, PaymentCls = self.type_map[(property_type, payment_type)]
        # 收集初始化参数
        property_args = PropertyCls.prompt_init()
        payment_args = PaymentCls.prompt_init()
        # 创建实例并组合组件
        property_instance = PropertyCls(**property_args, payment_component=PaymentCls(**payment_args))
        self.property_list.append(property_instance)

两种方案的对比 #

• 方案1的优势是结构清晰，每个组合类的职责明确，适合需求固定的场景；
• 方案2的优势是灵活性更高，后期可以轻松添加新的支付类型（比如Lease），不需要创建新的组合类，符合开闭原则。

总结 #

你不需要把Purchase和Rental作为Property的方法，而是应该把它们作为独立的功能组件，通过组合的方式和房产类结合。这样既避免了多重继承的复杂度，也让代码的职责划分更清晰，更容易维护和扩展。

内容的提问来源于stack exchange，提问作者ImustAdmit