quand utiliser if vs elif en python

Si j'ai une fonction avec plusieurs instructions conditionnelles où chaque branche est exécuté retours de la fonction. Dois-je utiliser plusieurs instructions if, ou if/elif/else? Par exemple, dire que j'ai une fonction:

def example(x):
    if x > 0:
        return 'positive'
    if x < 0:
        return 'negative'
    return 'zero'

Est-il mieux écrire:

def example(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

Les deux ont le même résultat, mais est un plus efficace ou considérés comme plus idiomatique que les autres?

Edit:

Un couple de gens ont dit que, dans le premier exemple, les deux si les déclarations sont toujours évalués, ce qui ne semble pas être le cas pour moi

par exemple, si je lance le code:

l = [1,2,3]

def test(a):
    if a > 0:
        return a
    if a > 2:
        l.append(4)

test(5)

l sera toujours égal à [1,2,3]

source d'informationauteur Sean Geoffrey Pietz

  1. 13

    Je vais développer mon commentaire pour une réponse.

    Dans le cas de tous les cas de retour, ceux-ci sont en effet équivalent. Ce qui devient important dans le choix d'entre eux est alors ce qui est plus lisible.

    Votre dernier exemple utilise la elif structure de préciser explicitement que les cas sont mutuellement exclusifs, plutôt que de compter sur le fait qu'ils sont implicitement à partir de la retourne. Cela rend les informations plus évident, et donc le code plus facile à lire, et moins sujette aux erreurs.

    Dire, par exemple, quelqu'un décide qu'il y a un autre cas:

    def example(x):
    if x > 0:
        return 'positive'
    if x == -15:
        print("special case!")
    if x < 0:
        return 'negative'
    return 'zero'

    Soudain, il y a un bug potentiel si l'utilisateur destiné à être mutuellement exclusifs (évidemment, cela ne fait pas beaucoup de sens compte tenu de l'exemple, mais aussi, potentiellement, pourrait, dans un exemple plus réaliste). Cette ambiguïté est levée si elifs sont utilisées et que le comportement est visible à la personne à ajouter du code au niveau qu'ils sont susceptibles d'être regarder quand ils l'ajouter.

    Si je devais venir à travers votre premier exemple de code, je n'aurais sans doute supposer que le choix de l'utilisation de ifs plutôt que de elifs implicite cas ont été pas mutuellement exclusifs, et des choses comme la modification de la valeur de x peut être utilisé pour modifier les ifs execute (évidemment, dans ce cas, l'intention est évidente et mutuellement exclusives, mais encore une fois, nous parlons de moins en moins évident de cas - et la consistance est bonne, de sorte que même dans un simple exemple, lorsqu'il est manifeste, il est préférable de s'en tenir à une seule voie).

  2. 3

    Dans certains cas, elif est nécessaire pour corriger la sémantique. C'est le cas lorsque les conditions ne sont pas mutuellement exclusives:

    if x == 0:   result = 0
elif y == 0: result = None
else:        result = x / y

    Dans certains cas, il est efficace parce que l'interprète n'a pas besoin de vérifier toutes les conditions, ce qui est le cas dans ton exemple. Si x est négatif, alors pourquoi ne vous cochez le cas positif? Un elif dans ce cas aussi rend le code plus lisible car elle montre clairement une seule branche sera exécuté.

  3. 1

    Vérifier cela de comprendre la différence:

    >>> a = 2
>>> if a > 1: a = a+1
...
>>> if a > 2: a = a+1
...
>>> a
4

    contre

    >>> a = 2
>>> if a > 1: a = a+1
... elif a > 2: a = a+1
...
>>> a
3

    Le premier cas est équivalent à deux distincts if's avec vide else états (ou imaginer else: pass); dans le second cas elif fait partie de la première if déclaration.

  4. 0

    elif est un peu plus efficace, et c'est tout à fait logique: avec ifs le programme doit évaluer chaque expression logique à chaque fois. Dans elifs bien, ce n'est pas toujours le cas. Cependant, dans votre exemple, cette amélioration serait très, très faible, probablement imperceptible, comme l'évaluation de x > 0 est l'un des moins chers des opérations.

    Lorsque l'on travaille avec elifs c'est aussi une bonne idée de réfléchir à la meilleure manière. Considérons cet exemple:

    if (x-3)**3+(x+1)**2-6*x+4 > 0:
    #do something 1
elif x < 0:
    #do something 2

    Ici le programme aura pour évaluer la vilaine expression de tous les temps! Cependant, si l'on change l'ordre:

    if x < 0:
   #do something 2
elif (x-3)**3+(x+1)**2-6*x+4 > 0:
   #do something 1

    Maintenant, le programme va d'abord vérifier si x < 0 (simple et bon marché) et que si elle ne l'est pas, il va évaluer l'expression plus complexe (btw, ce code n'a pas beaucoup de sens, c'est juste un hasard)

    Aussi, ce perreal dit.

  5. 0

    En général (par exemple, votre exemple), vous devez toujours utiliser un if..elif à l'échelle pour afficher explicitement les conditions sont mutuellement exclusifs. Il empêche l'ambiguïté, des bugs etc.

    La seule raison pour laquelle je peux penser que vous pourriez jamais de ne pas utiliser elif et l'utilisation if au lieu de cela le serait si les actions de l'organisme de la précédente if instruction (ou précédente elif états) ont peut-être changé la condition pour potentiellement faire plus mutuellement exclusifs. Il n'est donc plus vraiment une échelle, juste séparer concaténées if(..elif..else) blocs. (Laisser une ligne vide entre les blocs distincts, pour de bon style, et pour empêcher que quelqu'un accidentellement en pensant qu'il doit avoir été elif et "fixation")

    Voici un exemple artificiel, juste pour prouver le point:

    if total_cost>=10:
    if give_shopper_a_random_discount():
        print 'You have won a discount'
        total_cost -= discount
    candidate_prime = True

if total_cost<10:
    print 'Spend more than $10 to enter our draw for a random discount'

    Vous pouvez le voir, il est possible de toucher à la fois les conditions, si le premier si-bloc s'applique pour l'escompte, alors nous aussi exécuter la deuxième, qui imprime un message qui pourrait être source de confusion depuis l'origine, notre total avait été >=10.

    Un elif ici permettrait d'éviter ce scénario.
    Mais il pourrait y avoir d'autres scénarios où nous voulons que le deuxième bloc à courir, même pour ce scénario. 

    if total_cost<10:
    <some other action we should always take regardless of original undiscounted total_cost>