我正在尝试在Python中动态创建类，并且对于类和继承相对较新。基本上，我希望我的最终对象具有不同类型的历史记录，以满足不同的需求。我有一个解决方案，但我觉得一定有更好的方法。我想出了这样的东西。
class A:
def __init__(self):
self.history={}
def do_something():
pass
class B:
def __init__(self):
self.history=[]
def do_something_else():
pass
class C(A,B):
def __init__(self, a=False, b=False):
if a:
A.__init__(self)
elif b:
B.__init__(self)
use1 = C(a=True)
use2 = C(b=True)
你可能并不真正需要那个，这很可能是一个 XY 问题，但当你学习一门语言时，这种情况经常发生。你应该知道，通常情况下，你不需要像其他某些语言那样构建庞大的类层次结构。Python 使用“鸭子类型”——如果一个类拥有你想要使用的方法，只需调用它！
此外，在调用 __init__ 时，实例已经存在。此时你不能（容易地）将其替换为不同的实例（尽管任何事情都有可能）。
如果你真的希望能够实例化一个类，并根据传递给构造函数的内容获得本质上是完全不同对象的实例，则简单明了的做法是使用返回不同类的实例的函数。
然而，为了完整起见，你应该知道类可以定义一个__new__ 方法，在 __init__ 之前调用。这个方法可以返回类的实例、完全不同的类的实例或任何其他想要的东西。因此，例如，你可以这样做：
class A(object):
def __init__(self):
self.history={}
def do_something(self):
print("Class A doing something", self.history)
class B(object):
def __init__(self):
self.history=[]
def do_something_else(self):
print("Class B doing something", self.history)
class C(object):
def __new__(cls, a=False, b=False):
if a:
return A()
elif b:
return B()
use1 = C(a=True)
use2 = C(b=True)
use3 = C()
use1.do_something()
use2.do_something_else()
print (use3 is None)
这适用于Python 2或3。在使用3时，它会返回：
Class A doing something {}
Class B doing something []
True
class CAB(A, B):
'''uses A's __init__'''
class CBA(B, A):
'''uses B's __init__'''
use1 = CAB()
use2 = CBA()
def make_C(a=False, b=False):
if a:
return CAB()
elif b:
return CBA()
def make_C(a=False, b=False):
if a:
return type('C', (A, B), {})()
elif b:
return type('C', (B, A), {})()
两种用法如下：
use1 = make_C(a=True)
use2 = make_C(b=True)
def getValueClass(thetype):
"""Helper function for getting the `Value` class
Getting the named value class, based on `thetype`.
"""
# if thetype not in (int, float, complex): # if needed
# raise TypeError("The type is not numeric.")
class Value(thetype):
__text_signature__ = "(value, name: str = "")"
__doc__ = f"A named value of type `{thetype.__name__}`"
def __init__(self, value, name: str = ""):
"""Value(value, name) -- a named value"""
self._name = name
def __new__(cls, value, name: str = ""):
instance = super().__new__(cls, value)
return instance
def __repr__(self):
return f"{super().__repr__()}"
def __str__(self):
return f"{self._name} = {super().__str__()}"
return Value
IValue = getValueClass(int)
FValue = getValueClass(float)
CValue = getValueClass(complex)
iv = IValue(3, "iv")
print(f"{iv!r}")
print(iv)
print()
fv = FValue(4.5, "fv")
print(f"{fv!r}")
print(fv)
print()
cv = CValue(7 + 11j, "cv")
print(f"{cv!r}")
print(cv)
print()
print(f"{iv + fv + cv = }")
输出：
3
iv = 3
4.5
fv = 4.5
(7+11j)
cv = (7+11j)
iv + fv + cv = (14.5+11j)
>>> vi = IValue(4, "vi")
>>> vi
4
>>> print(vi)
vi = 4
>>> vf = FValue(3.5, 'vf')
>>> vf
3.5
>>> vf + vi
7.5
>>>
use3 = C(a=True, b=True)，会发生什么？ - eripC成为一个基类（包含你想要一直使用的任何方法和属性），而A和B应该是子类，用于特定情况下的类别化（例如self.history是一个特定类型）。按照你现在的设置，这没有任何意义。 - Blckknght