1) 定义一个表示电脑组件的抽象类Component，该类包含名称（name）和价格（price）两个属性，还包含一个描述组件信息的方法。以及一些get和set方法。 2) 由Component派生出CPU类（CPU），硬盘类（Disk）和显卡类（Vedio）。CPU类增加了新的属性：核心数，Disk类增加了新的属性：容量，Vedio类增加了属性：显存。 3) 创建Computer类（从Component派生）。Computer由CPU和Disk以及显卡等组成, 他们是一种依赖关系。 4) 这些部件和整机都可以工作但是工作方法不一样, 而这些工作方法定义在一个叫做Workable的接口中，即该接口中包含一个名为work的抽象方法。 5) 由CPU和Disk以及Vedio分别派生出具有不同品牌的子类，如IntelCPU、AMDCPU、SeagateDisk,ASUSVedio等。 6) 在测试类中对上述创建的接口和类进行测试。使用不同品牌的组件来组装两台Computer，并输出电脑的组件信息和工作方式（如**品牌的cpu在工作，**品牌的硬盘在工作，**品牌的显卡在工作）。

下面是该题的Python代码实现：

# 定义抽象类 Component
class Component:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    
    def get_name(self):
        return self.name
    
    def set_name(self, name):
        self.name = name
    
    def get_price(self):
        return self.price
    
    def set_price(self, price):
        self.price = price
    
    def describe(self):
        print("组件名称：{}，价格：{}".format(self.name, self.price))

# 由 Component 派生出 CPU、Disk 和 Vedio 类
class CPU(Component):
    def __init__(self, name, price, cores):
        super().__init__(name, price)
        self.cores = cores
    
    def get_cores(self):
        return self.cores
    
    def set_cores(self, cores):
        self.cores = cores
    
    def describe(self):
        print("CPU 名称：{}，价格：{}，核心数：{}".format(self.name, self.price, self.cores))

class Disk(Component):
    def __init__(self, name, price, capacity):
        super().__init__(name, price)
        self.capacity = capacity
    
    def get_capacity(self):
        return self.capacity
    
    def set_capacity(self, capacity):
        self.capacity = capacity
    
    def describe(self):
        print("硬盘名称：{}，价格：{}，容量：{}".format(self.name, self.price, self.capacity))

class Vedio(Component):
    def __init__(self, name, price, memory):
        super().__init__(name, price)
        self.memory = memory
    
    def get_memory(self):
        return self.memory
    
    def set_memory(self, memory):
        self.memory = memory
    
    def describe(self):
        print("显卡名称：{}，价格：{}，显存：{}".format(self.name, self.price, self.memory))

# 由 Component 派生出 Computer 类
class Computer(Component):
    def __init__(self, cpu, disk, vedio):
        self.cpu = cpu
        self.disk = disk
        self.vedio = vedio
    
    def get_cpu(self):
        return self.cpu
    
    def set_cpu(self, cpu):
        self.cpu = cpu
    
    def get_disk(self):
        return self.disk
    
    def set_disk(self, disk):
        self.disk = disk
    
    def get_vedio(self):
        return self.vedio
    
    def set_vedio(self, vedio):
        self.vedio = vedio
    
    def describe(self):
        print("电脑组件：")
        self.cpu.describe()
        self.disk.describe()
        self.vedio.describe()
    
    def work(self):
        print("{} 品牌的 CPU 在工作，{} 品牌的硬盘在工作，{} 品牌的显卡在工作".format(self.cpu.get_name(), self.disk.get_name(), self.vedio.get_name()))

# 由 CPU、Disk 和 Vedio 分别派生出具有不同品牌的子类
class IntelCPU(CPU):
    def __init__(self, cores):
        super().__init__("Intel", 500, cores)

class AMDCPU(CPU):
    def __init__(self, cores):
        super().__init__("AMD", 400, cores)

class SeagateDisk(Disk):
    def __init__(self, capacity):
        super().__init__("Seagate", 300, capacity)

class ASUSVedio(Vedio):
    def __init__(self, memory):
        super().__init__("ASUS", 800, memory)

# 测试类
if __name__ == '__main__':
    # 组装两台不同品牌的电脑
    computer1 = Computer(IntelCPU(8), SeagateDisk(1000), ASUSVedio(4))
    computer2 = Computer(AMDCPU(6), SeagateDisk(500), ASUSVedio(8))
    
    # 输出电脑的组件信息
    print("第一台电脑：")
    computer1.describe()
    print("第二台电脑：")
    computer2.describe()
    
    # 输出电脑的工作方式
    print("第一台电脑工作方式：")
    computer1.work()
    print("第二台电脑工作方式：")
    computer2.work()

输出结果为：

第一台电脑：
电脑组件：
CPU 名称：Intel，价格：500，核心数：8
硬盘名称：Seagate，价格：300，容量：1000
显卡名称：ASUS，价格：800，显存：4
第二台电脑：
电脑组件：
CPU 名称：AMD，价格：400，核心数：6
硬盘名称：Seagate，价格：300，容量：500
显卡名称：ASUS，价格：800，显存：8
第一台电脑工作方式：
Intel 品牌的 CPU 在工作，Seagate 品牌的硬盘在工作，ASUS 品牌的显卡在工作
第二台电脑工作方式：
AMD 品牌的 CPU 在工作，Seagate 品牌的硬盘在工作，ASUS 品牌的显卡在工作