Python Déclarations conditionnelles : IF…Else, ELIF et Switch Case

Que sont les instructions conditionnelles dans Python?

Instructions conditionnelles dans Python Ils effectuent différents calculs ou actions selon qu'une contrainte booléenne spécifique est évaluée à vrai ou à faux. Ils permettent à un programme de prendre des décisions et de suivre différents chemins au lieu d'exécuter chaque ligne séquentiellement. PythonLes instructions conditionnelles sont gérées par le if instruction et ses compagnons : else, elif et if imbriqué.

Qu'est-ce que le Python Si déclaration ?

Le Python if est utilisé pour les opérations de prise de décision. Il contient un bloc de code qui s'exécute uniquement si la condition spécifiée dans l'instruction if est vraie. Si la condition est fausse, l'instruction else (facultative) est exécutée à la place, contenant le code de la condition else. Lorsque vous souhaitez agir sur une condition alors qu'une autre est fausse, vous utilisez le Python instruction if-else.

Python if Syntaxe de l'instruction :

if expression:
    statement
else:
    statement

Python si…sinon

Le diagramme ci-dessus illustre le flux de contrôle à travers une instruction if-else. Prenons un exemple de Python L'instruction if-else en action :

# Example file for working with conditional statements
def main():
    x, y = 2, 8
    if(x < y):
        st = "x is less than y"
    print(st)

if __name__ == "__main__":
    main()

• Code Ligne 3: Nous définissons deux variables x, y = 2, 8.
• Code Ligne 4: L'instruction if vérifie la condition x < y, qui est Vrai dans ce cas.
• Code Ligne 5: La variable st est définie sur « x est inférieur à y ».
• Code Ligne 6: La ligne print(st) affiche la valeur de st, qui est « x est inférieur à y ».

Que se passe-t-il lorsque la condition « si » n'est pas remplie ?

En nous appuyant sur l'exemple précédent, voyons ce qui se passe lorsque la condition « si » est remplie. Python La condition n'est pas remplie. Lorsque la condition est fausse et qu'aucune branche « else » n'existe, le code indenté est entièrement ignoré.

# Example file for working with conditional statements
def main():
    x, y = 8, 4
    if(x < y):
        st = "x is less than y"
    print(st)

if __name__ == "__main__":
    main()

• Code Ligne 3: Nous définissons deux variables x, y = 8, 4.
• Code Ligne 4: L'instruction if vérifie la condition x < y, qui est Faux dans ce cas.
• Code Ligne 5: La variable st est pas réglé sur « x est inférieur à y ».
• Code Ligne 6: La ligne print(st) tente d'afficher une variable qui n'a jamais été déclarée, donc Python soulève un NomErreur.

Comment utiliser la condition « else »

Pour éviter l'erreur ci-dessus, vous pouvez ajouter une condition « else ». Cette condition est utilisée lorsqu'il faut évaluer une instruction en fonction d'une autre. Si une condition est fausse, le bloc « else » offre une alternative permettant au programme de produire un résultat.

Exemple :

# Example file for working with conditional statements
def main():
    x, y = 8, 4
    if(x < y):
        st = "x is less than y"
    else:
        st = "x is greater than y"
    print(st)

if __name__ == "__main__":
    main()

• Code Ligne 3: Nous définissons deux variables x, y = 8, 4.
• Code Ligne 4: L'instruction if vérifie la condition x < y, qui est Faux dans ce cas.
• Code Ligne 6: Le flux d'exécution du programme passe par la condition else.
• Code Ligne 7: La variable st est définie sur « x est plus grand que toi.
• Code Ligne 8: La ligne print(st) affiche la valeur de st, qui est « x est supérieur à y ».

Lorsque la condition « else » ne fonctionne pas

La condition « else » ne garantit pas toujours le résultat escompté. Elle peut afficher une sortie erronée en cas d'erreur dans la logique du programme. Cela se produit généralement lorsqu'il faut justifier plus de deux instructions ou conditions. Un exemple permettra de mieux comprendre ce concept.

Ici, les deux variables sont identiques (8, 8), pourtant le résultat du programme est « x est supérieur à y » lequel est FAUXCela se produit car le programme vérifie la première condition (la condition « si ») et, en cas d'échec, affiche la seconde condition (la condition « sinon ») par défaut. Nous verrons ensuite comment corriger cette erreur.

# Example file for working with conditional statements
def main():
    x, y = 8, 8
    if(x < y):
        st = "x is less than y"
    else:
        st = "x is greater than y"
    print(st)

if __name__ == "__main__":
    main()

Comment utiliser la condition « elif »

Pour corriger l'erreur précédente commise par la condition else, nous pouvons utiliser le Elif L'instruction `elif` permet d'indiquer au programme de tester une troisième possibilité lorsque la première condition est fausse. Vous pouvez enchaîner plusieurs instructions `elif` pour vérifier des possibilités supplémentaires (quatrième, cinquième, etc.) dans votre code.

Exemple :

# Example file for working with conditional statements
def main():
    x, y = 8, 8
    if(x < y):
        st = "x is less than y"
    elif(x == y):
        st = "x is same as y"
    else:
        st = "x is greater than y"
    print(st)

if __name__ == "__main__":
    main()

• Code Ligne 3: Nous définissons deux variables x, y = 8, 8.
• Code Ligne 4: L'instruction if vérifie la condition x < y, qui est Faux dans ce cas.
• Code Ligne 6: Le flux d'exécution du programme atteint la condition elif. Celle-ci vérifie si x == y, ce qui est vrai.
• Code Ligne 7: La variable st est définie sur « x est même que y. »
• Code Ligne 10: Le programme sort de l'instruction if (il n'atteindra pas l'instruction else) et affiche st. Le résultat est « x est identique à y », ce qui est correct.

Comment exécuter une instruction conditionnelle avec un minimum de code ? Code

Maintenant que vous pouvez écrire des blocs if-elif-else complets, Python permet de condenser une condition simple en une seule ligne. Au lieu d'écrire du code distinct pour chaque branche, vous pouvez utiliser une expression ternaire (conditionnelle).

syntaxe:

value_if_true if condition else value_if_false

Exemple :

def main():
    x, y = 10, 8
    st = "x is less than y" if (x < y) else "x is greater than or equal to y"
    print(st)

if __name__ == "__main__":
    main()

• Code Ligne 2: Nous définissons deux variables x, y = 10, 8.
• Code Ligne 3: La variable st prend la valeur « x est inférieur à y » si x < y ; sinon, elle prend la valeur « x est supérieur ou égal à y ». Comme x > y ici, st prend la deuxième valeur.
• Code Ligne 4: Affiche la valeur de st et donne le résultat correct.

Python Instruction if imbriquée

Une instruction if imbriquée place une instruction if à l'intérieur d'une autre, ce qui est utile lorsqu'une décision dépend d'une seconde condition. L'exemple suivant illustre une instruction if imbriquée. Python qui calcule le navireping Le prix dépend du pays et du montant total de la commande.

total = 100
# country = "US"
country = "AU"

if country == "US":
    if total <= 50:
        print("Shipping Cost is $50")
    elif total <= 100:
        print("Shipping Cost is $25")
    elif total <= 150:
        print("Shipping Cost is $5")
    else:
        print("FREE")

if country == "AU":
    if total <= 50:
        print("Shipping Cost is $100")
    else:
        print("FREE")

Décommentez la ligne 2 du code ci-dessus, commentez la ligne 3 et exécutez à nouveau le code pour voir comment le résultat change pour un pays différent.

Changer d'instruction de cas dans Python

Qu'est-ce qu'une instruction Switch ?

Une instruction switch est une instruction de branchement multiple qui compare la valeur d'une variable aux valeurs spécifiées dans des instructions case. Pendant de nombreuses années, Python Le langage ne disposait pas d'une instruction switch, les développeurs ont donc implémenté le même comportement avec Python dictionnaire planping.

Exemple utilisant une carte de dictionnaireping:

def switch_example(argument):
    switcher = {
        0: "This is Case Zero",
        1: "This is Case One",
        2: "This is Case Two",
    }
    return switcher.get(argument, "nothing")

if __name__ == "__main__":
    argument = 1
    print(switch_example(argument))

Changer de cas avec correspondance (Python 3.10 et Later)

Depuis que Python 3.10 (sorti en octobre 2021), Python fournit un natif étui d'allumettes Cette instruction, également appelée correspondance de motifs structurels, offre une alternative claire et lisible aux longues chaînes elif et à l'approche par dictionnaire présentée ci-dessus.

def switch_example(argument):
    match argument:
        case 0:
            return "This is Case Zero"
        case 1:
            return "This is Case One"
        case 2:
            return "This is Case Two"
        case _:
            return "nothing"

if __name__ == "__main__":
    print(switch_example(1))

Le trait de soulignement (_) agit comme cas par défaut, correspondant à toute valeur non gérée par les cas précédents, tout comme la valeur par défaut dans une instruction switch traditionnelle.

if vs elif vs else : Comparaison rapide

Utilisez cette comparaison pour déterminer quelle structure conditionnelle correspond à votre logique de prise de décision.

FAQ