如何在python中返回不同类型的重载sum函数的对象？

我有一个类

Data

，我想重载

\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

函数，并根据我求和的对象类型获得不同类型的对象

玩具示例代码

数据

类如下：

class Data(object):

    def __str__(self):
        s = "Data type " + self.type + ": " + self.tag
        return s

    def __init__(self, tag=""):
        self.type = ""
        self.tag = tag
        self.df = pd.Series()

    def createRandomData(self, amountData=10, sizeData=100):
        self.df = pd.DataFrame(np.random.randint(0,sizeData,size=(amountData, 1)))[0]

    def __add__(self, other):
        data = Data()
        data = Data(self.tag + "+" + other.tag)
        data.df = self.df + other.df
        return data

class Data(object):

    def __str__(self):
        s = "Data type " + self.type + ": " + self.tag
        return s

    def __init__(self, tag=""):
        self.type = ""
        self.tag = tag
        self.df = pd.Series()

    def createRandomData(self, amountData=10, sizeData=100):
        self.df = pd.DataFrame(np.random.randint(0,sizeData,size=(amountData, 1)))[0]

    def __add__(self, other):
        data = Data()
        if type(self) == type(other):
            if type(self) == DataTypeA:
                data = DataTypeA(self.tag + "+" + other.tag)
                data.df = self.df + other.df
            elif type(self) == DataTypeB:
                data = DataTypeB(self.tag + "+" + other.tag)
                data.df = self.df + other.df
        else:
            data = Data(self.tag + "+" + other.tag)
            data.df = self.df + other.df
        return data

我还有两个不同的对象

DataTypeA

和

DataTypeB

，它们继承自

Data

class DataTypeA(Data):

    def __init__(self, tag=""):
        Data.__init__(self, tag)
        self.type = "A"

class DataTypeB(Data):

    def __init__(self, tag=""):
        Data.__init__(self, tag)
        self.type = "B"

预期结果 因此，我想确保当我从同一类型的数据（例如：

DataTypeA

+

DataTypeA

）求和两个对象时，结果也是该类型的数据。但是当两个对象的类型不同时（例如：

DataTypeA

+

DataTypeB

），结果应该是一个

数据

对象

求和的结果应该是

df

中序列的和，标记应该是第一个对象的标记，并用“+”连接，最后是第二个标记

例子 现在，如果我运行以下代码：

a = DataTypeA("data1")
a.createRandomData()
b = DataTypeB("data2")
b.createRandomData()

a2 = a+a
b2 = b+b
c = a+b

print a
print b
print a2
print b2
print c

我得到的结果是：

>>> 
Data type A: data1
Data type B: data2
Data type : data1+data1
Data type : data2+data2
Data type : data1+data2

但是

a2

（data1+data1）应该是

DataTypeA

类型，而不是

Data

，

b2

（data2+data2）应该是

DataTypeB

类型，而不是

Data

class DataTypeA(Data):

    def __init__(self, tag=""):
        Data.__init__(self, tag)
        self.type = "A"

class DataTypeB(Data):

    def __init__(self, tag=""):
        Data.__init__(self, tag)
        self.type = "B"

问题:

---

如何重写这段代码来实现这一点，哪种方法是最好的？我应该为

数据

对象重写

\u添加

方法还是为

数据类型a

和

数据类型b

重写重载

\u添加

方法？

一个解决方案是重载

数据

对象

\u添加

方法，如下所示：

class Data(object):

    def __str__(self):
        s = "Data type " + self.type + ": " + self.tag
        return s

    def __init__(self, tag=""):
        self.type = ""
        self.tag = tag
        self.df = pd.Series()

    def createRandomData(self, amountData=10, sizeData=100):
        self.df = pd.DataFrame(np.random.randint(0,sizeData,size=(amountData, 1)))[0]

    def __add__(self, other):
        data = Data()
        data = Data(self.tag + "+" + other.tag)
        data.df = self.df + other.df
        return data

class Data(object):

    def __str__(self):
        s = "Data type " + self.type + ": " + self.tag
        return s

    def __init__(self, tag=""):
        self.type = ""
        self.tag = tag
        self.df = pd.Series()

    def createRandomData(self, amountData=10, sizeData=100):
        self.df = pd.DataFrame(np.random.randint(0,sizeData,size=(amountData, 1)))[0]

    def __add__(self, other):
        data = Data()
        if type(self) == type(other):
            if type(self) == DataTypeA:
                data = DataTypeA(self.tag + "+" + other.tag)
                data.df = self.df + other.df
            elif type(self) == DataTypeB:
                data = DataTypeB(self.tag + "+" + other.tag)
                data.df = self.df + other.df
        else:
            data = Data(self.tag + "+" + other.tag)
            data.df = self.df + other.df
        return data

代码的其余部分将保持不变

因此，如果您运行问题中提到的相同示例代码，则输出为：

>>> 
Data type A: data1
Data type B: data2
Data type A: data1+data1
Data type B: data2+data2
Data type : data1+data2