Самый элегантный способ настройки класса в Python?

Question

Я имитирую распределенную систему, в которой все узлы следуют за некоторым протоколом. Это включает в себя оценку некоторых небольших изменений в протоколе. Вариант означает альтернативную реализацию одного метода. Все узлы всегда придерживаются той же вариации, которая определяется конфигурацией эксперимента (только одна конфигурация активна в любой момент времени). Какой самый лучший способ сделать это, не жертвуя успехом?

Как эксперимент может быть довольно обширным, я явно не хочу никаких условностей. Прежде чем я только что использовал наследование, как:

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 ... 

Но теперь мне нужно, чтобы проверить все возможные варианты и не хочу экспоненциальное числа классов захламления источника. Я также хочу, чтобы другие люди смотрели на код, чтобы понять его с минимальными усилиями. Каковы ваши предложения?

Редактировать: Одна вещь, которую я не смог подчеркнуть достаточно: для всех предполагаемых случаев использования кажется, что исправление класса при конфигурации является хорошим. Я имею в виду: его можно заставить работать простым 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"