Pythonでクラスを設定する最もエレガントな方法は？

Question

私はすべてのノードが何らかのプロトコルに従う分散システムをシミュレートしています。これには、プロトコルの小さなバリエーションの評価も含まれます。変形とは、単一の方法の代替実施を意味する。 すべてノードは常に同じパターンに従います。パターンは実験設定によって決まります（ある時点で1つの設定だけが有効です）。パフォーマンスを犠牲にすることなく、最も明確な方法は何ですか？

実験が非常に広範囲になる可能性があるため、私は明らかに条件を必要としません。前に私は同じように、継承を使用しました：

class Node(object): 

    def dumb_method(self, argument): 
     # ...  

    def slow_method(self, argument): 
     # ... 

    # A lot more methods 

class SmarterNode(Node): 

    def dumb_method(self, argument): 
     # A somewhat smarter variant ... 

class FasterNode(SmarterNode): 

    def slow_method(self, argument): 
     # A faster variant ... 

しかし、今、私はすべての可能な変形にをテストする必要があるとソースを乱雑クラスの指数関数的な数を望んでいません。私はまた、他の人々が最小限の労力でコードを理解して理解してもらいたい。あなたの提案は何ですか？

編集：私が十分強調していなかったことの1つ：想定されているすべてのユースケースについて、設定時にクラスをパッチするのは良いと思われます。つまり、単純に作業することができます。Node.dumb_method = smart_methodしかし、どういうわけか、はという感じがしませんでした。この種の解決策は、ランダムなスマートリーダーに重大な頭痛を引き起こすでしょうか？あなたはこれに似た何かをしようとしている場合、私はわからない

Answer 1

type機能で新しいサブタイプを作成できます。サブクラスの名前空間をdictとして与えるだけです。

# these are supposed to overwrite methods 
def foo(self): 
    return "foo" 

def bar(self): 
    return "bar" 


def variants(base, methods): 
    """ 
     given a base class and list of dicts like [{ foo = <function foo> }] 
     returns types T(base) where foo was overwritten 
    """ 
    for d in methods: 
     yield type('NodeVariant', (base,), d) 


from itertools import combinations 
def subdicts(**fulldict): 
    """ returns all dicts that are subsets of `fulldict` """ 
    items = fulldict.items() 
    for i in range(len(items)+1): 
     for subset in combinations(items, i): 
      yield dict(subset) 

# a list of method variants 
combos = subdicts(slow_method=foo, dumb_method=bar) 

# base class 
class Node(object): 
     def dumb_method(self): 
      return "dumb" 
     def slow_method(self): 
      return "slow" 

# use the base and our variants to make a number of types 
types = variants(Node, combos) 

# instantiate each type and call boths methods on it for demonstration 
print [(var.dumb_method(), var.slow_method()) for var 
      in (cls() for cls in types)] 

# [('dumb', 'slow'), ('dumb', 'foo'), ('bar', 'slow'), ('bar', 'foo')] 

Answer 2

（スワップアウトランタイム「継承」を可能にする）：

class Node(object): 
    __methnames = ('method','method1')  

    def __init__(self, type): 
     for i in self.__methnames: 
      setattr(self, i, getattr(self, i+"_"+type)) 

    def dumb_method(self, argument): 
     # ...  

    def slow_method(self, argument): 
     # ... 

n = Node('dumb') 
n.method() # calls dumb_method 

n = Node('slow') 
n.method() # calls slow_method 

それとも、このような何かを探しているなら（可能に）クラスのすべてのメソッドの実行中の（したがってテスト）：

class Node(object): 
    #do something 

class NodeTest(Node): 

    def run_tests(self, ending = ''): 
     for i in dir(self): 
      if(i.endswith(ending)): 
       meth = getattr(self, i) 
       if(callable(meth)): 
        meth() #needs some default args. 
        # or yield meth if you can 

Answer 3

あなたは__slots__機構と、ファクトリクラスを使用することができます。それぞれの実験でNodeFactoryをインスタンス化する必要がありますが、そこからNodeインスタンスを作成することになります。例：

class Node(object): 
    __slots__ = ["slow","dumb"] 

class NodeFactory(object): 
    def __init__(self, slow_method, dumb_method): 
     self.slow = slow_method 
     self.dumb = dumb_method 
    def makenode(self): 
     n = Node() 
     n.dumb = self.dumb 
     n.slow = self.slow 
     return n 

の例では、実行します。

>>> def foo(): 
...  print "foo" 
... 
>>> def bar(): 
...  print "bar" 
... 
>>> nf = NodeFactory(foo, bar) 
>>> n = nf.makenode() 
>>> n.dumb() 
bar 
>>> n.slow() 
foo 

Answer 4

あなたはこのためにmetaclassを使用することができます。

場合によっては、バリエーションごとにメソッド名でその場でクラスを作成できます。

Answer 5

クラスがインスタンス化されたときまたは後で呼び出されるメソッドを決定する必要がありますか？クラスがインスタンス化されたと仮定すると、次のようになります。

class Node(): 
    def Fast(self): 
     print "Fast" 

    def Slow(self): 
     print "Slow" 

class NodeFactory(): 
    def __init__(self, method): 
     self.method = method 

    def SetMethod(self, method): 
     self.method = method 

    def New(self): 
     n = Node() 
     n.Run = getattr(n, self.method) 
     return n 

nf = NodeFactory("Fast") 

nf.New().Run() 
# Prints "Fast" 

nf.SetMethod("Slow") 

nf.New().Run() 
# Prints "Slow"