Ctrl+K

Branchement conditionnel

8. Branchement conditionnel#

Nous avons vu jusqu’à présent des programmes simples dans lesquels le déroulement est séquentiel, les instructions sont exécutées les unes après les autres.

Pour réaliser des programmes plus complexes, nous avons besoin d’introduire les structures de contrôle. Nous commençons avec le branchement conditionnel if, puis la boucle while. Pour les comprendre, nous aurons besoin d’un nouveau type de donnée, le type boolean que nous introduisons dans cette partie.

Plus tard, nous introduirons une troisième structure de contrôle, la boucle “pour chaque”.

8.1. Le branchement if#

L’instrution if permet, suivant une condition, d’exécuter ou non un ensemble d’instructions. Voici un exemple permettant le calcul d’une valeur absolue.

Python demande, à la ligne 1, la saisie d’une valeur. Si celle ci est négative, l’instruction de la ligne 3 sera exécutée. Ensuite le programme continuera et la valeur absolue sera affichée (ligne 4).

x = int(input("Saisir un nombre entier "))
if x<0 :
    x=-x
print( "La valeur absolue est : " + str( x ))

Voici un exemple plus complet dans lequel un programme affiche si l’utilisateur peut voter ou non. Il saisit son age puis, en fonction de celui ci, le programme affiche une phrase personalisée.

age = int(input('Saisissez votre age.'))

if age < 18 :
    print('Vous ne pouvez pas voter.')
elif age > 18 :
    print('Vous pouvez voter.')
else :
    print('Vous pouvez voter. Sans doute une premiere !')

La forme général de l’instruction conditionnelle if est décrite ci-dessous. Elle est composée de plusieurs ensembles d’instructions chacun associé à une condition, à l’exception du dernier. Lors de l’exécution, un seul groupe sera exécuté, celui associé à la première condition qui sera vérifiée. Si aucune condition n’est vérifiée alors le groupe d’instructions associé à else sera exécuté.

if condition_1 :
  instructions_1
elif condition_2 :
  instructions_2
elif condition_3 :
  instructions_3

...

else :
  instructions_else

Plusieurs éléments importants sont à noter. Tout d’abord, comme pour les fonctions, les instructions exécutées sont regroupées en blocs d’instructions. Ils sont précédés de : et marqués par une indentation, un décalage d’une tabulation ou 4 espaces vers la droite.

À l’exception du if et du bloc d’instructions qui lui est associé, les autres éléments sont optionnels. Le bloc else est toujours à la toute fin de l’instruction conditionnelle puisqu’il regroupe les instructions à exécuter si aucune condition n’a précédemment été vérifiée.

Enfin, on peut imbriquer des instructions conditionnelles les unes dans les autres. Les deux exemples suivants sont équivalent. Dans un cas on utilise une imbrication dans le second on utilise la notation elif.

# If imbriqué
x = int(input("x ?"))
if x < 0 :
   print( "x est negatif" )
else :
   if x > 0 :
       print( "x est positif" )
   else :
       print( "x est nul" )

# Utilisation de elif
x = int(input("x ?"))
if x < 0 :
   print( "x est negatif" )
elif x > 0 :
   print( "x est positif" )
else :
   print( "x est nul" )

Dans certains cas, il peut être nécessaire, plus simple ou plus lisible, d’énumérer tous les cas possibles pour un test même si certains ne doivent pas être associés à l’exécution d’instructions. On utilise alors l’instruction pass pour indiquer que l’on ne fait rien. Cette instruction est importante car : marque toujours le début d’un bloc qui doit être indenté, il faut donc toujours au moins une instruction même si celle-ci ne fait rien.

x = int(input("x ? "))
if x >= 0 :
   pass
else :
   x = -x

print( "Valeur absolue de x : " + str(x) )

On est maintenant capable, en combinant ce branchement conditionnel et ce que l’on a appris sur les fonctions, de créer une fonction qui calcule la valeur absolue d’un nombre.

def valeur_abs(x):
    if x >= 0:
        return x
    else:
        return -x

abs(-12)

Notons tout de même que Python dispose d’une fonction native abs(x) qui fait exactement ce calcul.

abs(-12)

12

8.2. Le type boolean#

Dans les exemples ci-dessus, nous utilisons des opérateurs de comparaison > et <. Ils produisent un résultat, comme les opérateurs sur les nombres, dont la valeur est soit vrai (True, attention à la majuscule), soit faux (False). On parle du type booléen.

Voici la liste des opérateurs produisant des valeurs booléennes.

  • == teste l’égalité entre deux éléments et renvoie True s’ils représentent la même valeur ; False sinon. Il ne faut pas confondre == avec l’affectation =.

  • != teste à l’inverse l’inégalité.

  • Les opérateurs d’ordre sont <, <=, => et >.

Il est possible de construire des expressions booléennes complexes à l’aide des trois opérateurs de logiques : and, or et not.

print( 5 == 4 )
print( True or False )
print( not(5 > 5 or False != (4 <= 10)) )

8.3. Exercices#

8.3.1. Opérations classiques avec les booléens#

Complétez les fonctions ci-dessous afin qu’elle réalise ce qui est indiqué. En exécutant votre code, des tests seront exécutés pour vous indiquez s’il existe des erreurs.

def is_even(x):
    """
    Cette fonction renvoie True si le nombre x est pair. False sinon.
    Remarque: on peut tester si un nombre est pair en comparant le
    reste de la division entiere (%) de x avec 2.
    """
    return False

def is_positive_integer(x):
    """
    Cette fonction renvoie True si le nombre x est un entier
    strictement positif. False sinon
    Remarque : on peut tester si un nombre est entier en
    comparant le reste de la division entiere (%) de x avec 1.
    """
    return False

8.3.2. Calcul de majorité absolue#

Nous souhaitons écrire un programme qui détermine si la majorité absolue d’un scrutin est atteinte. Il demande à l’utilisateur de saisir le nombre de suffrage exprimé, le nombre de voies “pour” et affiche si le “oui” l’emporte à la majorité absolue.

Pour cela, on rappelle que nous avons vu dans la section précédente comment calculer le modulo d’un nombre avec l’opérateur %. Ceci nous permet de savoir si un nombre est pair.

Pour tester votre programme nous donnons à titre indicatif des valeurs pour lesquels nous connaissons le résultat. Bien entendu il conviendrait de réaliser des tests plus pousser pour valider le programme. Une correction est proposée plus bas (par défaut elle est cachée).

Complétez la fonction majority ci-dessous. Elle prend deux paramètres, le nombre de suffrage exprimé (sufrage) et le nombre de vote oui.

def majority( sufrage, yes ) :
    # completer le code de cette fonction ...
    return False

Vous pouvez maintenant utiliser cette fonction majority dans un programme plus complet.

s = int(input("Combien de sufrages exprimes ? "))
y = int(input("Combien de voie pour ? "))
if majority(s, y) :
    print( "La motion passe." )
else :
    print( "La motion ne passe pas." )
Contenu