Manière pythonique d'éviter les instructions «if x: return x»

J'ai une méthode qui appelle 4 autres méthodes dans l'ordre pour vérifier les conditions spécifiques et renvoie immédiatement (sans vérifier les suivantes) chaque fois que l'on retourne quelque chose de vrai.

def check_all_conditions():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

Cela ressemble à beaucoup de code de bagages. Au lieu de chaque instruction if sur 2 lignes, je préfère faire quelque chose comme:

x and return x

Mais ce n'est pas Python invalide. Me manque-t-il une solution simple et élégante ici? Par ailleurs, dans cette situation, ces quatre méthodes de vérification peuvent être coûteuses, donc je ne veux pas les appeler plusieurs fois.

Vous pouvez utiliser une boucle:

conditions = (check_size, check_color, check_tone, check_flavor)
for condition in conditions:
    result = condition()
    if result:
        return result

Cela a l'avantage supplémentaire que vous pouvez maintenant rendre le nombre de conditions variable.

Vous pouvez utiliser map()+ filter()(les versions de Python 3, utilisez les future_builtinsversions de Python 2) pour obtenir la première valeur correspondante:

try:
    # Python 2
    from future_builtins import map, filter
except ImportError:
    # Python 3
    pass

conditions = (check_size, check_color, check_tone, check_flavor)
return next(filter(None, map(lambda f: f(), conditions)), None)

mais si c'est plus lisible, c'est discutable.

Une autre option consiste à utiliser une expression de générateur:

conditions = (check_size, check_color, check_tone, check_flavor)
checks = (condition() for condition in conditions)
return next((check for check in checks if check), None)

Alternativement à la bonne réponse de Martijn, vous pouvez enchaîner or. Cela retournera la première valeur véridique, ou Nones'il n'y a pas de valeur véridique:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor() or None

Démo:

>>> x = [] or 0 or {} or -1 or None
>>> x
-1
>>> x = [] or 0 or {} or '' or None
>>> x is None
True

Ne le change pas

Il existe d'autres façons de procéder, comme le montrent les diverses autres réponses. Aucun n'est aussi clair que votre code d'origine.

En fait, la même réponse que timgeb, mais vous pouvez utiliser des parenthèses pour un formatage plus agréable:

def check_all_the_things():
    return (
        one()
        or two()
        or five()
        or three()
        or None
    )

Selon la loi de Curly , vous pouvez rendre ce code plus lisible en divisant deux problèmes:

• Quelles sont les choses que je vérifie?
• Une chose est-elle revenue vraie?

en deux fonctions:

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions():
    for condition in all_conditions():
        if condition:
            return condition
    return None

Cela évite:

• structures logiques compliquées
• très longues lignes
• répétition

... tout en préservant un flux linéaire et facile à lire.

Vous pouvez probablement trouver des noms de fonctions encore meilleurs, selon votre situation particulière, ce qui les rend encore plus lisibles.

Ceci est une variante du premier exemple de Martijns. Il utilise également le style "collection de callables" afin de permettre les courts-circuits.

Au lieu d'une boucle, vous pouvez utiliser la fonction intégrée any.

conditions = (check_size, check_color, check_tone, check_flavor)
return any(condition() for condition in conditions) 

Notez que anyrenvoie un booléen, donc si vous avez besoin de la valeur de retour exacte du chèque, cette solution ne fonctionnera pas. anyne distinguera pas 14, 'red', 'sharp', 'spicy'comme des valeurs de retour, ils seront tous retournés comme True.

Avez-vous pensé à tout écrire if x: return xsur une seule ligne?

def check_all_conditions():
    x = check_size()
    if x: return x

    x = check_color()
    if x: return x

    x = check_tone()
    if x: return x

    x = check_flavor()
    if x: return x

    return None

Ce n'est pas moins répétitif que ce que vous aviez, mais IMNSHO, il se lit un peu plus fluide.

Je suis assez surpris que personne n'ait mentionné la fonction intégrée anyconçue à cet effet:

def check_all_conditions():
    return any([
        check_size(),
        check_color(),
        check_tone(),
        check_flavor()
    ])

Notez que bien que cette implémentation soit probablement la plus claire, elle évalue toutes les vérifications même si la première l'est True.

Si vous devez vraiment vous arrêter au premier échec de vérification, envisagez d'utiliser reducece qui est fait pour convertir une liste en une valeur simple:

def check_all_conditions():
    checks = [check_size, check_color, check_tone, check_flavor]
    return reduce(lambda a, f: a or f(), checks, False)

reduce(function, iterable[, initializer]): Appliquer la fonction de deux arguments cumulativement aux éléments de l'itérable, de gauche à droite, afin de réduire l'itérable à une seule valeur. L'argument de gauche, x, est la valeur cumulée et l'argument de droite, y, est la valeur de mise à jour de l'itérable. Si l'initialiseur optionnel est présent, il est placé avant les éléments de l'itérable dans le calcul

Dans ton cas:

• lambda a, f: a or f()est la fonction qui vérifie que l'accumulateur aou la vérification actuelle f()est True. Notez que si aest True, f()ne sera pas évalué.
• checkscontient des fonctions de vérification (l' félément du lambda)
• False est la valeur initiale, sinon aucune vérification ne se produirait et le résultat serait toujours True

anyet reducesont des outils de base pour la programmation fonctionnelle. Je vous encourage fortement à les former ainsi que mapce qui est génial aussi!

Si vous voulez la même structure de code, vous pouvez utiliser des instructions ternaires!

def check_all_conditions():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

Je pense que cela semble agréable et clair si vous le regardez.

Démo:

Pour moi, la meilleure réponse est celle de @ phil-frost, suivie de @ wayne-werner.

Ce que je trouve intéressant, c'est que personne n'a dit quoi que ce soit sur le fait qu'une fonction retournera de nombreux types de données différents, ce qui rendra alors obligatoire la vérification du type de x lui-même pour effectuer d'autres travaux.

Je mélangerais donc la réponse de @ PhilFrost avec l'idée de garder un seul type:

def all_conditions(x):
    yield check_size(x)
    yield check_color(x)
    yield check_tone(x)
    yield check_flavor(x)

def assessed_x(x,func=all_conditions):
    for condition in func(x):
        if condition:
            return x
    return None

Notez que cela xest passé comme argument, mais all_conditionsest également utilisé comme générateur passé de fonctions de vérification où toutes obtiennent un xà vérifier, et retournent Trueou False. En utilisant funcavec all_conditionscomme valeur par défaut, vous pouvez utiliser assessed_x(x)ou passer un autre générateur personnalisé via func.

De cette façon, vous obtenez xdès qu'un contrôle passe, mais ce sera toujours le même type.

Idéalement, je réécrirais les check_ fonctions à renvoyer Trueou Falseplutôt qu'une valeur. Vos chèques deviennent alors

if check_size(x):
    return x
#etc

En supposant que votre xn'est pas immuable, votre fonction peut toujours le modifier (bien qu'ils ne puissent pas le réaffecter) - mais une fonction appelée checkne devrait pas vraiment le modifier de toute façon.

Une légère variation sur le premier exemple de Martijns ci-dessus, qui évite le si à l'intérieur de la boucle:

Status = None
for c in [check_size, check_color, check_tone, check_flavor]:
  Status = Status or c();
return Status

J'aime @ timgeb. En attendant, je voudrais ajouter que l'expression Nonedans l' returninstruction n'est pas nécessaire car la collection d' orinstructions séparées est évaluée et la première non nulle, non vide, aucune-aucune est renvoyée et s'il n'y en a pas, elle Noneest renvoyée qu'il y en ait Noneou non!

Donc, ma check_all_conditions()fonction ressemble à ceci:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor()

En utilisant timeitavec, number=10**7j'ai regardé le temps d'exécution d'un certain nombre de suggestions. Par souci de comparaison, je viens d'utiliser la random.random()fonction pour renvoyer une chaîne ou Nonebasée sur des nombres aléatoires. Voici tout le code:

import random
import timeit

def check_size():
    if random.random() < 0.25: return "BIG"

def check_color():
    if random.random() < 0.25: return "RED"

def check_tone():
    if random.random() < 0.25: return "SOFT"

def check_flavor():
    if random.random() < 0.25: return "SWEET"

def check_all_conditions_Bernard():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

def check_all_Martijn_Pieters():
    conditions = (check_size, check_color, check_tone, check_flavor)
    for condition in conditions:
        result = condition()
        if result:
            return result

def check_all_conditions_timgeb():
    return check_size() or check_color() or check_tone() or check_flavor() or None

def check_all_conditions_Reza():
    return check_size() or check_color() or check_tone() or check_flavor()

def check_all_conditions_Phinet():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions_Phil_Frost():
    for condition in all_conditions():
        if condition:
            return condition

def main():
    num = 10000000
    random.seed(20)
    print("Bernard:", timeit.timeit('check_all_conditions_Bernard()', 'from __main__ import check_all_conditions_Bernard', number=num))
    random.seed(20)
    print("Martijn Pieters:", timeit.timeit('check_all_Martijn_Pieters()', 'from __main__ import check_all_Martijn_Pieters', number=num))
    random.seed(20)
    print("timgeb:", timeit.timeit('check_all_conditions_timgeb()', 'from __main__ import check_all_conditions_timgeb', number=num))
    random.seed(20)
    print("Reza:", timeit.timeit('check_all_conditions_Reza()', 'from __main__ import check_all_conditions_Reza', number=num))
    random.seed(20)
    print("Phinet:", timeit.timeit('check_all_conditions_Phinet()', 'from __main__ import check_all_conditions_Phinet', number=num))
    random.seed(20)
    print("Phil Frost:", timeit.timeit('check_all_conditions_Phil_Frost()', 'from __main__ import check_all_conditions_Phil_Frost', number=num))

if __name__ == '__main__':
    main()

Et voici les résultats:

Bernard: 7.398444877040768
Martijn Pieters: 8.506569201346597
timgeb: 7.244275416364456
Reza: 6.982133448743038
Phinet: 7.925932800076634
Phil Frost: 11.924794811353031

Cette façon est un peu en dehors de la boîte, mais je pense que le résultat final est simple, lisible et joli.

L'idée de base est raiseune exception lorsque l'une des fonctions est évaluée comme véridique et renvoie le résultat. Voici à quoi cela pourrait ressembler:

def check_conditions():
    try:
        assertFalsey(
            check_size,
            check_color,
            check_tone,
            check_flavor)
    except TruthyException as e:
        return e.trigger
    else:
        return None

Vous aurez besoin d'une assertFalseyfonction qui déclenche une exception lorsque l'un des arguments de la fonction appelée est évalué comme véridique:

def assertFalsey(*funcs):
    for f in funcs:
        o = f()
        if o:
            raise TruthyException(o)

Ce qui précède pourrait être modifié afin de fournir également des arguments pour les fonctions à évaluer.

Et bien sûr, vous aurez besoin de TruthyExceptionlui - même. Cette exception fournit le objectdéclencheur de l'exception:

class TruthyException(Exception):
    def __init__(self, obj, *args):
        super().__init__(*args)
        self.trigger = obj

Vous pouvez transformer la fonction d'origine en quelque chose de plus général, bien sûr:

def get_truthy_condition(*conditions):
    try:
        assertFalsey(*conditions)
    except TruthyException as e:
        return e.trigger
    else:
        return None

result = get_truthy_condition(check_size, check_color, check_tone, check_flavor)

Cela peut être un peu plus lent car vous utilisez à la fois une ifinstruction et la gestion d'une exception. Cependant, l'exception n'est gérée qu'une seule fois au maximum, de sorte que l'atteinte aux performances doit être mineure, sauf si vous prévoyez d'exécuter la vérification et d'obtenir une Truevaleur plusieurs milliers de fois.

La méthode pythonique utilise soit réduire (comme quelqu'un a déjà mentionné) ou itertools (comme indiqué ci-dessous), mais il me semble que le simple fait de court-circuiter l' oropérateur produit un code plus clair

from itertools import imap, dropwhile

def check_all_conditions():
    conditions = (check_size,\
        check_color,\
        check_tone,\
        check_flavor)
    results_gen = dropwhile(lambda x:not x, imap(lambda check:check(), conditions))
    try:
        return results_gen.next()
    except StopIteration:
        return None

Je vais sauter ici et je n'ai jamais écrit une seule ligne de Python, mais je suppose que if x = check_something(): return xc'est valide?

si c'est le cas:

def check_all_conditions():

    if (x := check_size()): return x
    if (x := check_color()): return x
    if (x := check_tone()): return x
    if (x := check_flavor()): return x

    return None

Ou utilisez max:

def check_all_conditions():
    return max(check_size(), check_color(), check_tone(), check_flavor()) or None

J'ai vu quelques implémentations intéressantes de déclarations switch / case avec dict dans le passé qui m'ont conduit à cette réponse. En utilisant l'exemple que vous avez fourni, vous obtiendrez ce qui suit. (C'est de la folie using_complete_sentences_for_function_names, c'est pourquoi il check_all_conditionsest renommé status. Voir (1))

def status(k = 'a', s = {'a':'b','b':'c','c':'d','d':None}) :
  select = lambda next, test : test if test else next
  d = {'a': lambda : select(s['a'], check_size()  ),
       'b': lambda : select(s['b'], check_color() ),
       'c': lambda : select(s['c'], check_tone()  ),
       'd': lambda : select(s['d'], check_flavor())}
  while k in d : k = d[k]()
  return k

La fonction de sélection élimine le besoin d'appeler chacun check_FUNCTIONdeux fois, c'est-à-dire que vous évitez check_FUNCTION() if check_FUNCTION() else nexten ajoutant une autre couche de fonction. Ceci est utile pour les fonctions de longue durée. Les lambdas dans le dict retardent l'exécution de ses valeurs jusqu'à la boucle while.

En bonus, vous pouvez modifier l'ordre d'exécution et même sauter certains tests en modifiant ket spar exemple en k='c',s={'c':'b','b':None}réduisant le nombre de tests et en inversant l'ordre de traitement d'origine.

Les timeitboursiers peuvent marchander sur le coût de l'ajout d'une couche supplémentaire ou deux à la pile et le coût de la recherche de dict, mais vous semblez plus préoccupé par la beauté du code.

Une implémentation plus simple peut également être la suivante:

def status(k=check_size) :
  select = lambda next, test : test if test else next
  d = {check_size  : lambda : select(check_color,  check_size()  ),
       check_color : lambda : select(check_tone,   check_color() ),
       check_tone  : lambda : select(check_flavor, check_tone()  ),
       check_flavor: lambda : select(None,         check_flavor())}
  while k in d : k = d[k]()
  return k

1. Je veux dire cela non pas en termes de pep8 mais en termes d'utilisation d'un mot descriptif concis à la place d'une phrase. Certes, l'OP peut suivre une convention de codage, travailler sur une base de code existante ou ne pas prendre en compte les termes laconiques dans leur base de code.