如何在基类的方法中访问子类的重写的类属性？ '__class__'仍然指向基类

Question

I want to create a set of class to manage different configuration arguments for different experiments. I want to set a list of attributes as the class attribute for each class to check if the attributes given is exactly needed.

To save codes, I write a general __init__ and wish it could apply to derived classes and use the derived class's _attr_ to do the checking work.

I use __class__ to refer to the current class but it seems to point to the base class.

Here are some codes. The __init__ function that BCDConfig inherent insists that _class__ should be the class where it is defined in -- ExpConfig.

import json

class ExpConfig:
    _attr_ = ['attr1', 'attr2']   # list of string

    def __init__(self, config):
        self.config = {}

        # only take defined attributes
        for key in config:
            if key in __class__._attr_:
                self.config[key] = config[key]
            else:
                raise ValueError

        # check if there is anything undefined
        for key in __class__._attr_:
            assert key in self.config, "Missing arguments!"

    def save_config(self, path):
        with open(path, 'w') as f:
            json.dump(self.config, f)

    @classmethod
    def load_config(cls, path):
        with open(path, 'r') as f:
            config = json.load(f)
        exp_config = __class__(config)
        return exp_config


class BCDConfig(ExpConfig):

    _attr_ = ['attr1', 'attr2', 'attr3']

    def __init__(self, config):
        super(BCDConfig, self).__init__(config)


if __name__ == '__main__':
    bcd_config1 = BCDConfig({'attr1':123, 'attr2':444})
    bcd_config1.save_config('./bcd1.cfg')
    print(BCDConfig.load_config('./bcd1.cfg').config)

    bcd_config2 = BCDConfig({'attr1':1253, 'attr2':4344, 'attr3':1})
    bcd_config2.save_config('./bcd2.cfg')
    print(BCDConfig.load_config('./bcd2.cfg'))

Here is the output. I wonder if there's a way other than __class__ that can be interpreted dynamically to the derived class. Thank you for any help!

{'attr1': 123, 'attr2': 444}
Traceback (most recent call last):
  File "C:/Users/MysriO/Documents/Local Codes/DEAP_Ricotta/exp_config.py", line 46, in <module>
    bcd_config2 = BCDConfig({'attr1':1253, 'attr2':4344, 'attr3':1})
  File "C:/Users/MysriO/Documents/Local Codes/DEAP_Ricotta/exp_config.py", line 37, in __init__
    super(BCDConfig, self).__init__(config)
  File "C:/Users/MysriO/Documents/Local Codes/DEAP_Ricotta/exp_config.py", line 14, in __init__
    raise ValueError
ValueError

Answer 1

__class__ is only ever going to point to the class that you defined the method on. It's purpose is not to change with subclasses.

Use the type() function , (eg type(self) ), if you want to get the class of the current instance. This returns self.__class__ in this case, but know that type() knows how to handle different types of objects, not just Python classes. It may be that you meant to use self.__class__ all along.

I'd not use __class__ unless you specifically want to access the class object on which a method was defined, ignoring inheritance, and then only with an explicit comment explaining why you do this. The __class__ closure is not widely known and not intended for general use.

From the reference documentation on class creation :

__class__ is an implicit closure reference created by the compiler if any methods in a class body refer to either __class__ or super . This allows the zero argument form of super() to correctly identify the class being defined based on lexical scoping, while the class or instance that was used to make the current call is identified based on the first argument passed to the method.

For the load_config classmethod, you already have a reference to the class: use cls there, not __class__ .

Next, you don't actually need the class reference in __init__ . You could use self._attr_ instead; class attributes are accessible via the instance, provided there are no instance attributes shadowing them:

class ExpConfig:
    _attr_ = ['attr1', 'attr2']   # list of string

    def __init__(self, config):
        self.config = {}

        # only take defined attributes
        for key in config:
            if key in self._attr_:
                self.config[key] = config[key]
            else:
                raise ValueError

        # check if there is anything undefined
        for key in self._attr_:
            assert key in self.config, "Missing arguments!"

The self._attr_ reference will find the _attr_ attribute on the correct class for the given instance:

>>> class ExpConfig:
...     _attr_ = ['attr1', 'attr2']
...
>>> class BCDConfig(ExpConfig):
...     _attr_ = ['attr1', 'attr2', 'attr3']
...
>>> ExpConfig()._attr_
['attr1', 'attr2']
>>> BCDConfig()._attr_
['attr1', 'attr2', 'attr3']

I'd actually make _attr_ a set object , not a list. Attribute names must be unique, don't need a specific order, and sets are optimised for membership testing and intersections. If you combine a set with dictionary views you can quickly test for missing and extraneous keys:

class ExpConfig:
    _attr_ = frozenset(('attr1', 'attr2'))   # immutable set of strings

    def __init__(self, config):
        extra = config.keys() - self.attrs
        if extra:
            raise ValueError(f"Invalid config keys: {', '.join(extra)}")
        missing = self.attrs - config.keys()
        if missing:
            raise ValueError(f"Missing config keys: {', '.join(missing)}")

        self.config = config.copy()

    def save_config(self, path):
        with open(path, 'w') as f:
            json.dump(self.config, f)

    @classmethod
    def load_config(cls, path):
        with open(path, 'r') as f:
            config = json.load(f)
        return cls(config)

I used a frozenset() object, an immutable set, because you probably don't want to alter the attribute names after creating your class. A frozenset() will protect you from accidental bugs that do so anyway.

Finally, subclasses can re-use definitions from a parent class with the set union operator | , so BCDConfig could be defined as:

class BCDConfig(ExpConfig):
    _attr_ = ExpConfig._attr_ | frozenset(('attr3',))