Question

高级开发人员希望我在Python中实现面向对象编程，我们使用Base类实例化所有对象创建。它并不适合我，因为Derived类必须实现Base类中的抽象方法。他只使用Base类作为实例化对象的方法的推理是，当我们遍历对象列表时，我们可以以相同的方式访问其变量和方法。由于基类的每个派生对象都具有比Base类更多的实例化属性，因此他建议 init 函数将* args和** kwargs作为参数的一部分。

这是一个很好的方法吗？如果没有，你能帮忙建议一个更好的选择吗？

这是一个简单的实施示例。

import abc
class Base(metaclass = abc.ABCMeta):
    def __init__(self, reqarg1, reqarg2, **kwargs):
        self.reqarg1 = reqarg1
        self.reqarg2 = reqarg2
        self.optarg1 = kwargs.get("argFromDerivedA", 0.123)
        self.optarg2 = kwargs.get("argFromDerivedB", False)
        self.dict = self.create_dict()

    @abstractmethod
    def create_dict(self):
        pass

    def get_subset_list(self, id):
        return [item for item in self.dict.values() if item.id == id] 

    def __iter__(self):
       for item in self.dict.values():
           yield item
    raise StopIteration()


class Derived_A(Base):
    def __init__(self, regarg1, regarg2, optarg1):
        super().__init__(regarg1, regarg2, optarg1)

    def create_dict(self):
        # some implementation
        return dict

class Derived_B(Base):
    def __init__(self, regarg1, regarg2, optarg2):
        super().__init__(regarg1, regarg2, optarg2)

    def create_dict(self):
        # some implementation
        return dict

编辑：为了说清楚，我不太清楚如何正确处理基类中的抽象方法，因为高级开发人员希望按如下方式使用它：

def main():
    b = Base(100, 200)
    for i in get_subset_list(30):
        print(i)

但是没有定义Base类中的dict，因为它是在派生类中定义的，因此会输出以下错误：

NameError：name＆＃39; abstractmethod＆＃39;未定义

Answer 1

您根本不必使用关键字参数;只需在函数的参数部分中使用默认值定义变量，并仅发送要从派生类发送的参数。

请注意，不必提供具有默认值的参数 - 这样您就可以使用具有范围数量的参数的函数（其中参数是唯一的，并且不能被视为列表）。

以下是部分示例（取自您的代码）：

import abc

class Base(metaclass = abc.ABCMeta):
    def __init__(self, reqarg1, reqarg2, optarg1 = 0.123, optarg2 = False):
        self.reqarg1, self.reqarg2 = reqarg1, reqarg2
        self.optarg1, self.optarg2 = optarg1, optarg2
    ...

class Derived_A(Base):
    def __init__(self, regarg1, regarg2, optarg1):
        super().__init__(regarg1, regarg2, optarg1=optarg1)
    ...

class Derived_B(Base):
    def __init__(self, regarg1, regarg2, optarg2):
        super().__init__(regarg1, regarg2, optarg2=optarg2)
    ...

编辑：随着问题的更新，我只给出一个小注释 - 抽象方法是为了确保一些派生的Base对象的混合列表可以调用相同的方法。 Base对象本身不能调用此方法 - 它对基类是抽象的，并且就在那里我们可以确保每个派生的实例都必须实现此方法。

Answer 2

我的建议是你在Base类中使用工厂类方法。您只需要能够根据提供的输入确定需要返回的Derived类。如果您提供关键字Derived_A，我会复制一个假定您需要optarg1的实现，如果您提供关键字Derived_B，我会复制optarg2。当然，这是完全人为的，您应该根据自己的需要进行更改。

import abc
class Base(metaclass = abc.ABCMeta):
    @classmethod
    def factory(cls,reqarg1,reqarg2,**kwargs):
        if 'optarg1' in kwargs.keys():
            return Derived_A(reqarg1=reqarg1,reqarg2=reqarg2,optarg1=kwargs['optarg1'])
        elif 'optarg2' in kwargs.keys():
            return Derived_B(reqarg1=reqarg1,reqarg2=reqarg2,optarg2=kwargs['optarg2'])
        else:
            raise ValueError('Could not determine Derived class from input')
    def __init__(self, reqarg1, reqarg2, optarg1=0.123, optarg2=False):
        self.reqarg1 = reqarg1
        self.reqarg2 = reqarg2
        self.optarg1 = optarg1
        self.optarg2 = optarg2
        self.dict = self.create_dict()
    @abc.abstractmethod
    def create_dict(self):
        pass

    def get_subset_list(self, id):
        return [item for item in self.dict.values() if item.id == id] 

    def __iter__(self):
        for item in self.dict.values():
            yield item

class Derived_A(Base):
    def __init__(self, reqarg1, reqarg2, optarg1):
        super().__init__(reqarg1, reqarg2, optarg1=optarg1)

    def create_dict(self):
        # some implementation
        dict = {'instanceOf':'Derived_A'}
        return dict

class Derived_B(Base):
    def __init__(self, reqarg1, reqarg2, optarg2):
        super().__init__(reqarg1, reqarg2, optarg2=optarg2)

    def create_dict(self):
        # some implementation
        dict = {'instanceOf':'Derived_B'}
        return dict

这将允许您始终创建一个Derived_X类实例，该实例将为您create_dict时定义__init__非抽象方法。

In [2]: b = Base.factory(100, 200)
ValueError: Could not determine Derived class from input

In [3]: b = Base.factory(100, 200, optarg1=1213.12)

In [4]: print(b.dict)
{'instanceOf': 'Derived_A'}

In [5]: b = Base.factory(100, 200, optarg2=True)

In [6]: print(b.dict)
{'instanceOf': 'Derived_B'}

此外，您可以拥有多个工厂方法。查看here获取简短教程。

使用基类进行所有对象创建

2 个答案: