Il est clair que python offre des possibilités très intéressantes pour faire de la programmation. Les blogs et les sites web qui font l’éloge de ce langage sont très nombreux, donc je ne compte pas en rajouter un de plus. Mais en revanche ce que je compte faire est de montrer (ou démonter) cette puissance en utilisant deux types d’outils incontournable de la programmation, à savoir les boucles et les conditions.

La boucle for

La boucle for est très utile lorsqu’on veut répéter une opération un certain nombre de fois. Imaginons par exemple que l’on souhaite résoudre l’équation suivante : 4x+5=6. Et pour ce faire on souhaite trouver la valeur de x qui vérifie l’égalité. On va parcourir une liste de nombre, et à chaque fois on remplace x par un nombre et on regarde si l’égalité est vérifiée. 

Voici la liste de nombres que l’on veut parcourir :

L = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29]

Le même calcul se répétera pour chaque membre de la liste. On utilisera donc la boucle for pour l’automatiser.

Une petite remarque au passage, en langage python, on écrit les nombres décimaux avec des points et non des virgule.

Voici la syntaxe de cette boucle :

L = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11,
0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29]
for x in L:
    print(4*x + 5)

Et comme on peut le constater, on commence par définir la liste que l’on veut parcourir, on l’a appelé L. Ensuite on a codé la boucle for. La syntaxe est très simple mais il faut respecter 2 règles :

• La première ligne de la boucle se termine toujours par deux points ( : ). Cette première ligne peut être traduite de la manière suivante :
  • Pour chaque membre de la liste L : faire les instructions suivantes. 
• Il faut mettre une « indentation » un espace (tabulation) avant toutes les lignes suivantes qui contiennent des instructions à boucler. Dans notre exemple, il s’agit d’afficher le calcul de la partie de l’équation qui contient l’inconnue x.

Une des raisons pour laquelle on utilise un IDE ou un éditeur de texte compatible avec le langage python, est le fait qu’il gère automatiquement les la structure du code et les indentations. 

Et voici le résultat obtenu par ce programme :

[5.0, 5.04, 5.08, 5.12, 5.16, 5.2, 5.24, 5.28, 5.32, 5.36, 5.4, 5.44, 5.48, 5.52, 5.56, 5.6, 5.64, 5.68, 5.72, 5.76, 5.8, 5.84, 5.88, 5.92, 5.96, 6.0, 6.04, 6.08, 6.12, 6.16]

Pour déterminer la solution de l’équation, il faut chercher dans la liste ci-dessus, la valeur qui vérifie l’égalité, à savoir 6. Et comme on peut le constater le calcul qui donne la valeur 6 correspond à la valeur de x=0.25.

Les conditions 

Et s’il existait un moyen qui permet d’afficher directement la valeur de x qui vérifie l’égalité de l’équation. Sans afficher toutes la liste des résultats, cela nous épargnerait de parcourir les deux listes pour trouver la solution.

La condition if

La structure de la condition if est la suivante : 

for x in L:
    y = 4*x + 5
    if y == 6:
        print("x = ", x, "est la solution de l'équation 4*x + 5 = 6")

C’est le même code que précédemment, à la différence qu’on stocke le résultat du calcul dans une variable y, ensuite, on utilise la condition if pour savoir si y est égale au 2^ème membre de l’équation, et seulement si c’est le cas on affiche la valeur de x qui vérifie cette égalité. Et voici la solution que le programme affiche :

x =  0.25 est la solution de l’équation 4*x + 5 = 6

Donc ici le programme n’affiche que la solution, car la seule instruction qu’on a mis dans la condition (if) est d’afficher la phrase réponse.

La condition if else

Imaginons que l’on souhaite afficher les valeurs de x qu’on a testé mais qui ne sont pas solution de l’équation, le script serait le suivant :

for x in L:
    y = 4*x + 5
    if y == 6:
        print("x = ", x, "est la solution de l'équation 4*x + 5 = 6")
    else:
        print("x = ", x, "n'est pas la solution ")

Ce programme affichera le résultat suivant :

• […]
• x =  0.24 n’est pas la solution 
• x =  0.25 est la solution de l’équation 4*x + 5 = 6
• x =  0.26 n’est pas la solution
• […]

Ce qu’on peut remarquer c’est que le programme ne s’arrête pas quand il trouve la valeur de x qui est solution de l’équation. On pourrait donc optimiser le programme en le forçant à s’arrêter dès qu’il trouve la solution de l’équation. On utilise pour cela l’instruction (break) juste après l’affichage de la solution. 

L = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11,
 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19,
 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29]
for x in L:
    y = 4*x + 5
    if y == 6:
        print("x = ", x, "est la solution de l'équation 4*x + 5 = 6")
        break

Algorithme pour chercher une valeur dans une liste avec la boucle for

Cette dernière version du programme est la version optimale, et voici l’algorithme qui lui correspond : 

• Créer une liste de valeur dans un intervalle susceptible de contenir la solution de l’équation ;
• Pour chaque valeur de cette liste remplacer x par cette valeur et :
  • Calculer le membre de l’équation qui contient x et stocker le résultat dans la variable y
  • Tester l’égalité entre y et le 2^ème membre de l’équation
    • Si la condition est vraie alors afficher la valeur de x (solution de l’équation) et arrêter la boucle (for)
    • Sinon continuer à parcourir la liste des valeurs

Cet algorithme peut être effectué en utilisant un autre type de boucle.

Algorithme pour chercher une valeur dans une liste avec la boucle while

While en anglais voudrait dire tant que. While est une boucle conditionnée, voici l’algorithme avec la boucle while :

• Affecter une valeur à x
• Incrémenter cette valeur tant qu’elle n’est pas solution de l’équation

x = 0
while (4*x + 5) != 6:
    x = x + 0.01
print('Voici la solution : ', x)

Pour que ce programme marche, il faut bien choisir la valeur initiale de x et le pas d’incrémentation. Ce type de boucle est dangereux car elle peut tourner indéfiniment. 

En effet, la solution de l’équation est bien entendu x = 0.25, le fait de prendre une valeur initiale à 0, puis de l’incrémenter de 0.01, on est sûr qu’on se dirige vers la bonne solution. Imaginons qu’au lieu de prendre 0 comme valeur initiale, on prend une valeur supérieur de la solution attendue (1 par exemple) le fait d’incrémenter cette valeur initiale de 0.01 ne fait que nous éloigner de la solution, la boucle ne s’arrêtera donc jamais !

C’est pour cela qu’avant d’utiliser la boucle while, il faudra penser au préalable à au moins une méthode pour l’arrêter.

Exercices d’entrainement :

Exercice 1

Écrire un programme qui parcoure les valeurs des premiers nombre entiers positifs et qui permet d’afficher la valeur actuelle, la valeur précédente et la somme de la valeur actuelle et la valeur précédente

Exercice 2

Écrire un programme qui parcoure les lettres d’une chaine de caractère et qui affiche séparément les lettres en tenant compte des doublons.

Exemple : pour la chaine de caractère « cours-maths-python » le résultat à afficher est ‘c’ ‘o’ ‘u’ ‘r’ ‘s’ ‘-‘ ‘m’ ‘a’ ‘t’ ‘h’ ‘p’ ‘y’ ‘n’