Python类方法构造子类

Question

我不知道如何在python中干净利落地重用派生类的classmethod来构造子类：

class Base:
     def __init__(... lots of parameters .... )
         ... assign parameters .... 
         
     @classmethod
     def from_file(cls,file)
         .... read lots of parameters ....
         return cls(.... lots of parameters .... )

class Derived(Base):
     def __init__(derived_param, .... base parameters ..... )
         super().__init__(base parameters)

     @classmethod
     def from_file(cls,file)
         ??? do i have to replicate the whole code from   
         Base.from_file() here ???? 

Answer 1

您不必在子类中重新定义方法。默认情况下，它使用父函数：

class Base:
     def __init__(... lots of parameters .... )
         ... assign parameters .... 
         
     @classmethod
     def from_file(cls,file)
         .... read lots of parameters ....
         return cls(.... lots of parameters .... )

class Derived(Base):
     def __init__(derived_param, .... base parameters ..... )
         super().__init__(base parameters)

derived_class = Derived(...params...)
derived_class.from_file(...params...)  # This line will work without any further changes

Answer 2

现在是花哨的答案：

class Base:
    def __init__(self, **params):
        self.assign(params,['base_x','base_y'])

    def assign(self,params,required):
        for k in required:
            # will throw an exception if a required variable is not present
            self.__dict__[k] = params[k]


    @classmethod
    def from_file(cls):
        """ read from file here"""
        return cls(base_x='xval',base_y='yval')


class Derived(Base):
    def __init__(self, **params):
        super().__init__(**params) # it does not hurt to have all the derived params in the dict
        self.assign(params,['derived_var']) # here we assign only the derived vars, note this has to be a list

    @classmethod
    def from_file(cls):
        base = Base.from_file()
        derived_dict = { 'derived_var' : 'derived value'}
        derived = cls( **(derived_dict | base.__dict__) )
        return derived


if __name__ == '__main__':
    derived = Derived.from_file()
    print("Base: ", derived.base_x, derived.base_y," Derived: ", derived.derived_var)

这样你只需要在每个子类中指定所需的属性，如果你错过了一个关键错误就会抛出一个关键错误。

Answer 3

解决方法似乎是在 Derived.from_file() 方法中实际调用 Base.from_file() 并传递参数。

class Base:
    def __init__(self,base_var):
        self.base_var = base_var

    @classmethod
    def from_file(cls):
        """ read from file here"""
        base_init = "base_init"
        return cls(base_var=base_init)


class Derived(Base):
    def __init__(self,derived_var,base_var):
        super().__init__(base_var)
        self.derived_var = derived_var

    @classmethod
    def from_file(cls):
        derived_init = "derived_init"
        base = Base.from_file()
        derived = cls(derived_init,base.base_var)

        return derived

Answer 4

类方法接收调用该方法的类作为第一个参数。

如果你写

d = Derived.from_file(3)

然后调用的是在Base 中定义的from_file 函数，但使用Derived，而不是Base，作为第一个参数（绑定到cls）。结果，您将获得正确类的实例。

但是，如果您需要使用文件执行 Derived 特定的事情，您仍然需要覆盖该方法并使用 super() 在您自己的 Derived 之前执行任何 Base 特定的事情-具体的事情。

class Base:
     def __init__(*, x, y, z, **kwargs)
         super().__init__(**kwargs)
         # assign x, y, z
         
     @classmethod
     def from_file(cls, file)
         # Process file to get values for x, y, and z
         return cls(x=..., y=..., z=...)

class Derived(Base):
     def __init__(*, a, b, c, **kwargs )
         super().__init__(**kwargs)
         # assign a, b, c

     @classmethod
     def from_file(cls, file)
         obj = super().from_file(file)
         # Do additional work with obj
         return obj