Le bloc else : exécuter du code si aucune exception n'est levée

Qu'est-ce que le bloc else ? Un complément à try et except

Le bloc `else` est un bloc de code optionnel qui peut être ajouté à une structure `try...except` en Python. Il est placé après le bloc `try` et le(s) bloc(s) `except`.

Le code à l'intérieur du bloc `else` est exécuté *uniquement si* le bloc `try` se termine *normalement*, c'est-à-dire si *aucune* exception n'est levée dans le bloc `try`.

Le bloc `else` permet de séparer le code qui doit être exécuté en cas de succès du code qui doit être exécuté en cas d'erreur.

Il permet d'éviter d'ajouter du code supplémentaire au bloc `try` qui ne serait pas nécessaire s'il n'y avait pas de risque d'erreur

Syntaxe du bloc else : après try et except

Syntaxe :

try:
    # Code susceptible de lever une exception
    # ...
except ExceptionType:
    # Code pour gérer l'exception
    # ...
else:
    # Code à exécuter si aucune exception n'est levée dans le bloc try
    # ...

• Le bloc `else` est placé après le bloc `try` et le(s) bloc(s) `except`.
• Le bloc de code indenté après `else:` est le bloc `else`. Il est exécuté si et seulement si aucune exception n'est levée dans le bloc `try`.

Exemple :

try:
    resultat = 10 / 2  # Pas d'erreur ici
except ZeroDivisionError:
    print("Division par zéro !")
else:
    print("Le résultat est :", resultat)  # Cette ligne sera exécutée

Résultat :

Le résultat est : 5.0

Exemple (avec une exception) :

try:
    resultat = 10 / 0  # Division par zéro !
except ZeroDivisionError:
    print("Division par zéro !")
else:
    print("Le résultat est :", resultat)  # Cette ligne ne sera PAS exécutée

Résultat :

Division par zéro !

Dans le premier exemple, le bloc `try` se termine normalement (pas d'exception), donc le bloc `else` est exécuté. Dans le deuxième exemple, une `ZeroDivisionError` est levée dans le bloc `try`, donc le bloc `except` est exécuté, et le bloc `else` est *ignoré*.

Pourquoi utiliser else ? Avantages et clarté du code

L'utilisation du bloc `else` n'est pas obligatoire, mais elle peut rendre le code plus clair et plus facile à lire. Elle permet de distinguer clairement :

• Le code qui peut lever une exception (dans le bloc `try`).
• Le code qui gère l'exception (dans le bloc `except`).
• Le code qui doit être exécuté *uniquement si* aucune exception n'est levée (dans le bloc `else`).

Sans le bloc `else`, vous devriez placer le code qui doit être exécuté en cas de succès *à l'intérieur* du bloc `try`, après le code potentiellement problématique. Cela peut rendre le code moins lisible, car il devient moins évident de distinguer le code "à risque" du code "de succès".

Exemple (sans `else`, moins clair) :

try:
    resultat = 10 / x
    print("Le résultat est :", resultat)  # Cette ligne fait-elle partie du code "à risque" ?
except ZeroDivisionError:
    print("Division par zéro !")

Exemple (avec `else`, plus clair) :

try:
    resultat = 10 / x
except ZeroDivisionError:
    print("Division par zéro !")
else:
    print("Le résultat est :", resultat)  # Clairement : cette ligne n'est exécutée qu'en cas de succès

Le bloc `else` permet de mieux structurer le code et de rendre l'intention du programmeur plus explicite.

Exemple concret : calcul et affichage d'un résultat

Voici un exemple concret d'utilisation du bloc `else` :

try:
    nombre = int(input("Entrez un nombre entier : "))
    resultat = 100 / nombre
except ValueError:
    print("Erreur : Vous devez entrer un nombre entier.")
except ZeroDivisionError:
    print("Erreur : Division par zéro.")
else:
    print(f"Le résultat de 100 divisé par {nombre} est : {resultat}")

Dans cet exemple :

• Le bloc `try` tente de convertir l'entrée utilisateur en entier et de calculer 100 divisé par ce nombre.
• Le premier bloc `except` gère l'exception `ValueError` (si l'utilisateur n'entre pas un nombre entier).
• Le deuxième bloc `except` gère l'exception `ZeroDivisionError` (si l'utilisateur entre 0).
• Le bloc `else` affiche le résultat *uniquement si* aucune exception n'a été levée (c'est-à-dire si l'entrée utilisateur était un entier valide et non nul).

else en combinaison avec finally

Il est possible de combiner `else` et `finally` dans une même structure `try...except...else...finally`.

L'ordre est toujours le suivant :

1. `try`
2. `except` (un ou plusieurs blocs)
3. `else` (optionnel)
4. `finally` (optionnel)

Le bloc `finally` est *toujours* exécuté, que le bloc `else` ait été exécuté ou non (c'est-à-dire, qu'il y ait eu une exception ou non).

Exemple:

try:
  x = int(input('Entrez un chiffre: '))
  y = 10 / x
except ValueError:
  print('Veuillez entrer un chiffre')
except ZeroDivisionError:
  print('Division par zéro')
else:
  print(f'Le résultat est {y}')
finally:
  print('Fin du programme')