导入和使用数据作为对象属性的Python方法

Question

I am working with data that is used as variables after they are imported. I would like to then use the variables in an object as attributes.

So far I have accomplished this by writing an ImportData class and then it is composed into another class, Obj, that uses it for other calculations. Another solution i have used, is to inherit from the ImportData class. I have an example below:

defining data class

class ImportData:
    def __init__(self, path):
        # open file and assign to some variables
        # such as:
        self.slope = 1
        self.intercept = -1

solution 1: use composition

class Obj:
    def __init__(self, data_object):
        self.data = data_object

    def func(self, x):
        return self.data.slope*x + self.data.intercept


data_object = ImportData('<path>')
obj = Obj(data_object)

# get the slope and intercept
print('slope =', obj.data.slope, '  intercept =', obj.data.intercept)

# use the function
print('f(2) =', obj.func(2))

solution 2: use inheritance

class Obj(ImportData):
    def __init__(self,path):
        super().__init__(path)

    def func(self, x):
        return self.slope*x + self.intercept

obj = Object('<path>')
# get the slope and intercept
print('slope =', obj.slope, '  intercept =', obj.intercept)

# use the function
print('f(2) =', obj.func(2))

I don't like the composition solution because I have to type an extra "data" every time I need to access an attribute but I'm not sure inheritance is the right way to go either.

Am I out in left field and there is better solution?

Answer 1

Your sense that the chained attribute access in the composed solution is a code smell is correct: data is an implementation detail of Obj and should be hidden from Obj 's clients, so if the implementation of the ImportData class change, you only have to change Obj and not every class that calls obj.data .

We can hide Obj.data by giving Obj a __getattr__ method to control how its attributes are accessed.

>>> class ImportData:
...     def __init__(self, path):
...         self.slope = 1
...         self.intercept = -1
... 
>>> data = ImportData()


>>> class Obj:
...     def __init__(self, data_object):
...         self.data = data_object

...     def func(self, x):
...         return self.slope*x + self.intercept

...     def __getattr__(self, name):
...         try:
...             return getattr(self.data, name)
...         except AttributeError:
...             raise AttributeError('{} object has no attribute {}.'.format(self.__class__.__name__, name))

>>> o = Obj(data)
>>> o.func(2)
1
>>> o.slope
1
>>> o.intercept
-1
>>> 

Normally, if python fails to find an attribute of an object - for example obj.slope - it will raise an AttributeError . However if the object has a __getattr__ method python will call __getattr__ instead of raising an exception.

In the above code, Obj.__getattr__ looks for the attribute on data if it doesn't exist on Obj , so Obj 's clients can call obj.slope instead of obj.data.slope . The re-raising of AttributeError is done so that the error message refers to Obj rather than ImportData