2つのクラスインスタンス間の数値のデルタを計算します

Question

私は一束の計算を実行するPythonクラスを持っています。このクラスはさまざまな計算をサポートしています。これらの計算のそれぞれは実際に呼び出されるかどうかは関係ありません。ここに例があります：

class MyCalc(object): 
    def __init__(user, query_date, award): 
     self.user = user 
     self.query_date = query_date 
     self.award = award 

    def balance(self): # this can be subtracted 
     return self.award.balance 

    def value(self): # this can be subtracted 
     if self.user.award_date > self.query_date: 
      return self.award.value * self.user.multiplier 
     return 0 

    def has_multiple_awards(self): # this can not be subtracted 
     return self.user.awards > 2 

    def as_pandas_series(self): 
     return pd.Series({'balance': self.balance(), 
       'value': self.value(), 
       'query_date': self.query_date, 
       'award': self.award, 
       'user': self.user}) 

私が欲しいのは、クラスの2つのインスタンスの違いを計算することです。私は次のアプローチを考え出しましたが、この方法に欠点があるかどうか、あるいはもっと良い方法があるかどうかはわかりません。

class Diff(object): 
    def __init__(self, a, b): 
     self.a = a 
     self.b = b 

    def __getattr__(self, attr): 
     getter = operator.attrgetter(attr) 
     closing = getter(self.a)() 
     opening = getter(self.b)() 
     return closing - opening 

a = MyCalc() 
b = MyCalc() 
diff = Diff(a, b) 
print(diff.calc_x) # calculate a.calc_x() - b.calc_x() 

代わりに私はデコレータを追加することができますし、Diffのクラスを使用しないでください：

def differance(func): 
    def func_wrapper(self): 
     return func(self) - func(self.b) 
    return func_wrapper 


class MyCalc(object): 
    @difference 
    def calc_x(self): 
     return some_calc 

    @difference 
    def calc_y(self): 
     return some_calc 

すべてのフィードバックが理解されるであろう。

Answer 1

あなたDiffクラスは、私には正常に見えるが、私はまだ、これはPython的であるかどうかは未定です。 ;）私は大きな欠点は見当たりませんが、より効率的にすることができます。

Diffクラスの代替実装を次に示します。これは、それぞれ__getattr__コールで検索を行う必要がなく、operator.attrgetterの2つのコールを行う必要がないので、もう少し効率的です。代わりに、functools.partialと組み込みのgetattr関数を使用して属性アクセス関数をキャッシュします。

また、私はテスト目的のために簡単なMyCalcクラスを実装しました。

from functools import partial 

class MyCalc(object): 
    def __init__(self, u, v): 
     self.u = u 
     self.v = v 

    def calc_x(self): 
     return self.u + self.v 

    def calc_y(self): 
     return self.u * self.v 

class Diff(object): 
    def __init__(self, a, b): 
     self.geta = partial(getattr, a) 
     self.getb = partial(getattr, b) 

    def __getattr__(self, attr): 
     closing = self.geta(attr)() 
     opening = self.getb(attr)() 
     return closing - opening 


a = MyCalc(10, 20) 
b = MyCalc(2, 3) 

diff = Diff(a, b) 
print(diff.calc_x) 
print(diff.calc_y) 

a.u, a.v = 30, 40 
b.u, b.v = 4, 7 
print(diff.calc_x) 
print(diff.calc_y) 

出力

25 
194 
59 
1172 

Answer 2

import operator 

class MyCalc(object): 
    def __init__(self, x=0, y=0, *args): 
     self.x = x 
     self.y = y 

    def calc_x(self): 
     return self.x * 2 

    def calc_y(self): # There's about 15 of these calculations 
     return self.y/2 

class Diff(object): 
    def __init__(self, a, b): 
     self.a = a 
     self.b = b 

    def _diff(self, func, *args): 
     getter = operator.attrgetter(func) 
     closing = getter(self.a)() 
     opening = getter(self.b)() 
     return closing - opening 


a = MyCalc(50) 
b = MyCalc(100) 

diff = Diff(a, b) 

ret = diff._diff("calc_x") 
print ret 


>>> -100 

Answer 3

あなたがまたは呼び出さない場合がありますいくつかはすべて返却数値は、あなたのクラスは、約15の計算をサポートして言います。 クリーンで最もPython的なのは、1つのベクトル、つまりNumPy配列（またはPandas SeriesまたはDataFrame）を返すメソッドを1つ持つように思われます。クライアントコードは単にベクトル減算を行うことができます：ab_diff = a.calc() - b.calc()。あなたが記述したものに基づいて、np.arrayにホイールを再開発する必要はないようです。

これらの計算のうちのほんの一部が計算に費やされない場合や、計算コストが高い場合は、calc()とcalc_rare()にリファクタリングすることができます。または、あなたはcalc(..., compute_latlong=False, compute_expensive_stuff=False)にkwargsを渡すことができます。ベクトルの長さを一定に保つために、デフォルトで計算しない高価なもののデフォルト値としてnp.NaNを返すことができます。

import numpy as np 
#import pandas as pd 

class MyCalc(object): 
    def __init__(self, ...): ... 

    # (You can either have 15 calculation methods, or use properties. 
    # It depends on whether any of these quantities are interrelated 
    # or have shared dependencies, especially expensive ones.) 
    def calc_q(self): ... 
    def calc_r(self): ... 
    def calc_s(self): ... 
    ... 
    def calc_y(self): ... 
    def calc_z(self): ... 

    # One main calc() method for the client. (You might hide the 
    # other calc_* methods as _calc_*, or else in properties.) 
    def calc(self): 
     return np.array([ calc_q(), calc_r(), calc_s(), 
      ... calc_y(), calc_z() ]) # Refactor this as you see fit 

if __name__ == '__main__': 
    # Client is as simple as this 
    a = MyCalc(...) 
    b = MyCalc(...) 
    ab_diff = a.calc() - b.calc()