我正在尝试创建一个可以使用 **kwargs 初始化的类系统,并且每个字段都有默认值。这是一些代表我正在尝试做的事情的代码:
class Parent(object): #should only have p_var fields
DEFAULTS = {
"p_var_1" : "my name",
"p_var_2" : 2
}
def __init__(self, **kwargs):
for key in DEFAULTS:
#Also include check for list type and copy, not assign
if key in kwargs:
setattr(self, key, kwargs[key])
else:
setattr(self, key, self.DEFAULTS[key])
#Check for super being 'object' - problems?
#if not super() == object:
# super().__init__(**kwargs)
class Gen1(Parent): #should have p_var and G1_var fields
DEFAULTS = {
"G1_var_1" : "Generation 1",
"G1_var_2" : []
}
#redefining only in case if Parent can't check for super
def __init__(self, **kwargs):
for key in DEFAULTS:
#Also include check for list type and copy, not assign
if key in kwargs:
setattr(self, key, kwargs[key])
else:
setattr(self, key, self.DEFAULTS[key])
#check whether super() is object
super().__init__(**kwargs) #pass all args to parent init
class Gen2(Gen1): #should have p_var, G1_var and G2_var fields
DEFAULTS = {
"G2_var_1" : 1337,
"G2_var_2" : (10,4)
}
#After Gen1, redefining __init__ shouldn't be necessary
所以在设置了几个实例之后:
Gen2item1 = Gen2()
Gen2item2 = Gen2(p_var_1 = "different name", G2_var_1 = 666)
Gen2item1 将被初始化为所有默认值:
- Gen2item1.p_var_1 是“我的名字”
- Gen2item1.p_var_2 为 2
- Gen2item1.G1_var_1 是“第 1 代”
- Gen2item1.G1_var_2 是 [](复制)
- Gen2item1.G2_var_1 是 1337 并且
- Gen2item1.G2_var_2 是 (10,4)
但 Gen2item1 将具有不同的 p_var_1 和 G2_var_1 值,其余相同。 但是,由于“DEFAULT”在子类中被覆盖,因此 Gen2item1 值:
- Gen2item1.p_var_1 为 666
- Gen2item1.p_var_2 是 (10,4)
由每一代(级别)设置三次,G1_var 或 p_var 值未设置。对于 Gen2item2,所有三代 __init__ 都将 G2_var_1 设置为 666,将 G2_var_2 设置为 (10,4)。
所以底线问题是关于为每个类生成一些“默认”字段(dict)的方法,以便:
- 通过
item = subclass()调用子类的__init__时,它会根据 'defaults' dict 从kwargs获取参数 key , - 通过
setattrib(self, key, value)设置自己的字段,如果存在来自 defaults 的键,则从 kwargs 中获取值,否则也从 defaults 中获取值,并且 - 通过
super()__init__(**kwargs)传递 kwargs 时调用其父级的 init。
然后,父类以相同的方式为子类的同一实例设置其生成的字典定义的默认值,调用并传递给其父类的 __init__,依此类推,直到父类为 object,在这种情况下,super().__init__ 根本不会被调用/传递参数给。
我读过有关元类的内容,这似乎有些矫枉过正,并且 got my hopes high on this ,它有一个单独的父类和子类实例。
有没有办法在没有元类的情况下实现这样的目标?将默认值存储在外部全局字典中会更好吗(在这种情况下,将不胜感激一些寻址帮助),或者有没有办法建立一个工厂?
已解决的编辑:
__init_subclass__ 可以工作并且几乎可以满足我的要求,前提是它还为要初始化的类定义了 __init__(我的项目的具体细节)。这可以回答我的问题,并提供了一些有用的信息来说明如何在我的项目中实现我想要的设置。我相信定义一个设置适当的 __init__ 并在定义类时运行它的类方法就足够了(这是非常新的 __init_subclass__ 似乎这样做的有帮助),但至少要有一些向后兼容性,元类似乎是做到这一点的方法。
请您参考如下方法:
您可以使用在 Python 3.6 中添加到 object() 的新类方法:__init_subclass__
此方法在类被子类化时调用,允许您在不使用元类的情况下自定义子类的创建。
你的例子看起来像这样:
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__()
for key, value in kwargs.items():
setattr(cls, key, value)
def __init__(self, *args, **kwargs):
super().__init__()
for key, value in kwargs.items():
setattr(self, key, value)
class Parent(Base, p_var_1='my_name', p_var_2=2):
pass
class Gen1(Parent, G1_var_1='Generation 1', G1_var_2=[]):
pass
class Gen2(Gen1, G2_var_1=1337, G2_var_2=(10,4)):
pass
