Refactoring si des instructions en python

Question

Je voudrais consulter un morceau de code avec vous. J'ai:

if tuple_type == Operation.START_SERVER: 
    dictionary = ServersDictionary() 
    dictionary.start(some_param) 
elif tuple_type == Operation.STOP_SERVER: 
    dictionary = ServersDictionary() 
    dictionary.stop(some_param) 
(...) 
elif tuple_type == Operation.START_APP: 
    dictionary = AppsDictionary() 
    dictionary.start(some_param) 
elif ... 
(....) 

Et là j'ai 27 if/elifs. Normalement, j'irais dans le répartiteur de carte - fonction, mais après chaque if/elif j'ai deux lignes de code avec le même dictionnaire référence. Me suggérez-vous une solution propre pour remplacer ces constructions laides? Créer 27 classes pour appliquer le polymorphisme ou 27 fonctions ne sonne pas bien ... qu'en pensez-vous?

Answer 1

Vous pouvez inclure les informations méta dans vos énumérations, si cela est ok pour vous code client, ce qui signifie que vous possédez les énumérations. Voici un exemple:

class Operation(Enum): 
    START_SERVER = (0, "start", ServersDictionary) 
    STOP_SERVER = (1, "stop", ServersDictionary) 
    START_APP = (1, "start", AppsDictionary) 

et d'avoir une seule fonction pour gérer vos opérations:

def handle_operation(operation, some_param): 
    klass = operation.klass 
    dictionary = klass() 
    fn = getattr(dictionary, operation.value) 
    fn(some_param) 

Ceci est en supposant que vous utilisez le Enum que vous aviez dans l'une de vos questions. Dans ce cas, vous devrez ajouter une ligne là:

class Enum(object): 
    __metaclass__ = EnumMeta 

    def __init__(self, value): 
     super(Enum, self).__init__() 

     self.value, self.repr, self.klass = value[0], value[1], value[2] 

    def __repr__(self): 
     return str(self.repr) 

Ensuite, vous aurez pas besoin de contrôles de cas, simplement:

handle_operation(tuple_type) 

Answer 2

Vous avez raison, une cartographie est la voie à suivre. Utilisez getattr pour accéder à une méthode de son nom:

mapping = {Operation.START_SERVER: (ServerDictionary, 'start', some_param), 
      Operation.STOP_SERVER: (ServerDictionary, 'stop', some_param), 
      Operation.START_APP: (AppsDictionary, 'start', some_param)} 
... 
cls, method, param = mapping[tuple_type] 
dictionary = cls() 
getattr(dictionary, method)(param) 

Answer 3

Peut-être que vous pouvez représenter l'opération avec un dict ou Tupple, comme

op = {'target': 'Servers', 'action': 'start', 'params': (arg1, arg2)}

alors vous pouvez y accéder comme

obj = globals()[op['target']+'Dictionary']() 
getattr(obj, op['action'])(*op['params'])