Python - 像扩展函数一样扩展属性

Question

问题

如何扩展 python 属性？

子类可以通过在重载版本中调用超类的功能，然后对结果进行操作来扩展超类的功能。下面是我所说的“扩展函数”的一个例子：

# Extending a function (a tongue-in-cheek example)

class NormalMath(object):
    def __init__(self, number):
        self.number = number

    def add_pi(self):
        n = self.number
        return n + 3.1415


class NewMath(object):
    def add_pi(self):
        # NewMath doesn't know how NormalMath added pi (and shouldn't need to).
        # It just uses the result.
        n = NormalMath.add_pi(self)  

        # In NewMath, fractions are considered too hard for our users.
        # We therefore silently convert them to integers.
        return int(n)

是否有类似于扩展函数的操作，但对于使用属性装饰器的函数？

我想在获得计算成本高的属性后立即进行一些额外的计算。我需要保持属性的访问惰性。我不希望用户必须调用一个特殊的例程来进行计算。基本上，我不希望用户知道计算是首先进行的。但是，该属性必须保留为属性，因为我有需要支持的遗留代码。

也许这是装饰师的工作？如果我没记错的话，装饰器是一个包装另一个函数的函数，我希望用更多的计算来包装一个属性，然后再次将其呈现为一个属性，这似乎是一个类似的想法......但我不太清楚。

我的具体问题

我有一个基类 LogFile，它具有构造成本高的属性 .dataframe。我已经将它实现为一个属性（使用属性装饰器），所以在我请求数据帧之前它实际上不会解析日志文件。到目前为止，它工作得很好。我可以构造一堆（100 多个）LogFile 对象，并使用更便宜的方法来过滤并仅选择要解析的重要对象。每当我一遍又一遍地使用同一个 LogFile 时，我只需要在第一次访问数据帧时解析它。

现在我需要编写一个 LogFile 子类 SensorLog，它在基类的数据帧属性中添加了一些额外的列，但我不太清楚调用超类的数据帧构造的语法例程（对它们的内部工作一无所知），然后对生成的数据帧进行操作，然后然后缓存/返回它。

# Base Class - rules for parsing/interacting with data.
class LogFile(object):
    def __init__(self, file_name):
        # file name to find the log file
        self.file_name = file_name
        # non-public variable to cache results of parse()
        self._dataframe = None

    def parse(self):
        with open(self.file_name) as infile:
            ...
            ...
            # Complex rules to interpret the file 
            ...
            ...
        self._dataframe = pandas.DataFrame(stuff)

    @property
    def dataframe(self):
        """
        Returns the dataframe; parses file if necessary. This works great!

        """
        if self._dataframe is None:
            self.parse()
        return self._dataframe

    @dataframe.setter
    def dataframe(self,value):
        self._dataframe = value


# Sub class - adds more information to data, but does't parse
# must preserve established .dataframe interface
class SensorLog(LogFile):
    def __init__(self, file_name):
        # Call the super's constructor
        LogFile.__init__(self, file_name)

        # SensorLog doesn't actually know about (and doesn't rely on) the ._dataframe cache, so it overrides it just in case.
        self._dataframe = None

    # THIS IS THE PART I CAN'T FIGURE OUT
    # Here's my best guess, but it doesn't quite work:
    @property
    def dataframe(self):
        # use parent class's getter, invoking the hidden parse function and any other operations LogFile might do.
        self._dataframe = LogFile.dataframe.getter()    

        # Add additional calculated columns
        self._dataframe['extra_stuff'] = 'hello world!'
        return self._dataframe


    @dataframe.setter
    def dataframe(self, value):
        self._dataframe = value

现在，当在交互式会话中使用这些类时，用户应该能够以相同的方式与其中任何一个进行交互。

>>> log = LogFile('data.csv')
>>> print log.dataframe
#### DataFrame with 10 columns goes here ####
>>> sensor = SensorLog('data.csv')
>>> print sensor.dataframe
#### DataFrame with 11 columns goes here ####

我有很多现有代码，它们采用 LogFile 实例，该实例提供 .dataframe 属性并执行一些有趣的操作（主要是绘图）。我希望 SensorLog 实例呈现相同的界面，以便它们可以使用相同的代码。是否可以扩展超类的数据帧获取器以利用现有例程？如何？还是我最好换一种方式？

感谢您阅读那堵巨大的文字墙。亲爱的读者，您是互联网超级英雄。有什么想法吗？

Answer 1

如果我理解正确，您想要做的是从子实例调用父方法。通常的方法是使用内置的super。

我取了你的半开玩笑的例子，并将其修改为使用super，以便向你展示：

class NormalMath(object):
    def __init__(self, number):
        self.number = number

    def add_pi(self):
        n = self.number
        return n + 3.1415


class NewMath(NormalMath):
    def add_pi(self):
        # this will call NormalMath's add_pi with
        normal_maths_pi_plus_num = super(NewMath, self).add_pi()
        return int(normal_maths_pi_plus_num)

在您的日志示例中，而不是调用：

self._dataframe = LogFile.dataframe.getter() 

你应该打电话：

self._dataframe = super(SensorLog, self).dataframe

你可以阅读更多关于超级here

编辑：即使我给您的示例处理的是方法，对@properties 做同样的事情也不应该是个问题。

Answer 2

问题是你错过了进入父类的自我。如果您的父母是单身人士，那么 @staticmethod 应该可以工作。

class X():
    x=1
    @staticmethod
    def getx():
        return X.x

class Y(X):
    y=2
    def getyx(self):
        return X.getx()+self.y

wx = Y()
wx.getyx()
3

Answer 3

您可以考虑一些可能性：

1/ 从logfile 继承并在派生的传感器类中覆盖parse。无论dataframe 拥有多少成员，都应该可以修改您在dataframe 上工作的方法以使其工作 - 因为您正在使用pandas，其中很多都是为您完成的。

2/ 使sensor 成为logfile 的实例，然后提供自己的解析方法。

3/ 概括parse，可能还有其他一些方法，以使用数据描述符列表和可能的方法/规则字典，这些方法/规则要么在你的类初始化器中设置，要么由方法设置。

4/ 考虑更多地使用 pandas 中已有的方法，或者如果您和其他人认为 pandas 会接受它们作为有用的扩展，则可能扩展 pandas 以提供缺少的方法。

我个人认为您会发现选项 3 或 4 的好处是最强大的。

Answer 4

您应该调用超类属性，而不是通过self._dataframe 绕过它们。这是一个通用示例：

class A(object):

    def __init__(self):
        self.__prop = None

    @property
    def prop(self):
        return self.__prop

    @prop.setter
    def prop(self, value):
        self.__prop = value

class B(A):

    def __init__(self):
        super(B, self).__init__()

    @property
    def prop(self):
        value = A.prop.fget(self)
        value['extra'] = 'stuff'
        return value

    @prop.setter
    def prop(self, value):
        A.prop.fset(self, value)

并使用它：

b = B()
b.prop = dict((('a', 1), ('b', 2)))
print(b.prop)

输出：

{'a': 1, 'b': 2, 'extra': 'stuff'}

我通常建议将副作用放在 setter 而不是 getter 中，如下所示：

class A(object):

    def __init__(self):
        self.__prop = None

    @property
    def prop(self):
        return self.__prop

    @prop.setter
    def prop(self, value):
        self.__prop = value

class B(A):

    def __init__(self):
        super(B, self).__init__()

    @property
    def prop(self):
        return A.prop.fget(self)

    @prop.setter
    def prop(self, value):
        value['extra'] = 'stuff'
        A.prop.fset(self, value)

通常也要避免在 getter 中进行昂贵的操作（例如您的 parse 方法）。