La manière la plus efficace de faire une déclaration if-elif-elif-else lorsque le else est le plus utilisé ?

Question

J'ai une instruction if-elif-elif-else dans laquelle, dans 99 % des cas, l'instruction else est exécutée :

if something == 'this':
    doThis()
elif something == 'that':
    doThat()
elif something == 'there':
    doThere()
else:
    doThisMostOfTheTime()

Cette construction se fait beaucoup mais comme il passe en revue chaque condition avant d'atteindre l'autre, j'ai l'impression que ce n'est pas très efficace, et encore moins pythonique. D'un autre côté, il a besoin de savoir si l'une de ces conditions est remplie, donc il devrait quand même la tester.

Quelqu'un sait-il si et comment cela pourrait être fait plus efficacement ou est-ce simplement la meilleure façon de procéder ?

Answer 1

Récemment, j'ai découvert une approche alternative aux "if else imbriqués" qui réduit le temps d'exécution de ma fonction de 2,5 heures à ~2 minutes Baam ! Commençons :

Code antérieur
bin = lambda x : "Unknown" if x==0 else("High" if x>75 else("Medium" if x>50 and x<=75 else("Medium_Low" if x>25 and x<=50 else "Low")))

col.apply(bin) Durée ~2,5 heures

Optimiser le code

Définir Dictionnaire alternative à nid si else

 def dict_function(*args):
'Pass in a list of tuples, which will be key/value pairs'
ret = {}
for k,v in args:
    for i in k:
        ret[i] = v
return ret
Dict = dict_function(([0],"Unknown"),(range(1,25),"Low"),(range(25,50),"Medium_Low"),(range(50,75),"Medium"),(range(75,100),"High"))

col.apply(lambda x:Dict[x])

La fonction dict_fonction crée plusieurs paires clé-valeur pour une plage donnée. Temps~2mins

Answer 2

J'ai eu le même problème récemment, bien que ne concernant pas les performances, mais je n'aime pas l'"API" consistant à créer des fonctions et à les ajouter manuellement à un dict. Je voulais une API similaire à functools.singledispatch mais pour répartir sur la base des valeurs et non des types. Donc...

def value_dispatch(func):
    """value-dispatch function decorator.
    Transforms a function into a function, that dispatches its calls based on the
    value of the first argument.
    """
    funcname = getattr(func, '__name__')
    registry = {}

    def dispatch(arg):
        """return the function that matches the argument"""
        return registry.get(arg, func)

    def register(arg):
        def wrapper(func):
            """register a function"""
            registry[arg] = func
            return func
        return wrapper

    def wrapper(*args, **kwargs):
        if not args:
            raise ValueError(f'{funcname} requires at least 1 positional argument')
        return dispatch(args[0])(*args, **kwargs)

    wrapper.register = register
    wrapper.dispatch = dispatch
    wrapper.registry = registry
    return wrapper

Utilisez comme ça :

@value_dispatch
def handle_something():
    print("default")

@handle_something.register(1)
def handle_one():
    print("one")

handle_something(1)
handle_something(2)

PS : J'ai créé un extrait sur Gitlab pour référence