Aller au contenu

4. Structures de contrôle : boucles⚓︎

4.1 Principe⚓︎

En programmation, un principe important est le principe DRY. Cet acronyme signifie Don't Repeat Yourself. Il suggère qu'un bon programme informatique ne contient pas de répétitions et évite les copier/coller.

Si votre programme comporte trop de répétitions, il faut utiliser de nouvelles structures permettant d'éviter cela.

Utilité des boucles

On veut ajouter quatre pièces de 2€ dans une urne. Voici le programme proposé.

urne = 0 # urne videbksl-nlurne = urne + 2 # première pièce dans l'urnebksl-nlurne = urne + 2 # seconde pièce dans l'urnebksl-nlurne = urne + 2bksl-nlurne = urne + 2bksl-nl

  • Affichez le contenu de l'urne dans le terminal.
  • Complétez le programme ci-dessus afin d'ajouter 2 nouvelles pièces de 2€ (total de 6 pièces).
  • Imaginez que l'on veuille maintenant ajouter 5 nouvelles pièces. Complétez le programme ci-dessus.
  • Et pour 7296 nouvelles pièces, comment feriez-vous ?

En programmation, on est amené à répéter de nombreuses fois une même instruction ou bloc d'instructions. On introduit donc une nouvelle structure de contrôle appelée boucles.

On distingue :

  • les boucles conditionnelles ;
  • les boucles inconditionnelles.

4.2 Définition générale⚓︎

Cours

Graphe de controle

graph TD; A[début code]-->p("condition"); p-->|Vrai|B[bloc code A]-->p; p-->|Faux|C[suite code]; class p if;

Une boucle est une structure de contrôle permettant de répéter un bloc d'instructions selon une certaine condition.

Ce type d'instructions est essentielle à tout langage de programmation.

Comprendre l'intérêt des boucles

Le programme suivant comporte-t-il une boucle ?

1
2
3
4
Faites fondre le chocolat cassé en morceaux avec le beurre.
Battez les oeufs avec le sucre jusqu'à ce que le mélange blanchisse.
Ajoutez la farine, le sucre vanillé, et ajoutez le chocolat.
Versez le tout dans un moule, et enfournez à 180°C pendant 15 min.

Solution

Ce programme ne comporte pas de boucle. Chaque instruction est exécutée une seule fois.

Le programme suivant comporte-t-il une boucle ?

1
2
3
4
5
6
7
Pour multiplier 12 par un nombre entier n, on fait :
resultat = 0              # 0 fois
resultat = resultat + 12  # 1 fois
resultat = resultat + 12  # 2 fois
resultat = resultat + 12  # 3 fois
...
resultat = resultat + 12  # n fois

Solution

Ce programme comporte une boucle. Chaque instruction est répétée n fois (n peut même être égal à 0!).

La condition est cachée. On continue tant que l'addition n'a pas été répétée n fois.

Le programme suivant comporte-t-il une boucle ?

1
2
3
4
Mettre l'eau dans le sucre et mettre le plein feu pendant 3 minutes.
À l'aide d'un thermomètre de cuisson, mesurez la température.
Tant que la température n'est pas supérieure à 127°C, ajoutez 1 minute de cuisson puis mesurez à nouveau la température.
Une fois la température supérieure à 127°C, retirez du feu.

Solution

Ce programme comporte une boucle. Une instruction (la mesure de température) doit être répétée autant de fois que nécessaire pour dépasser les 127°C.

La condition est donc temperature >= 127°C.

Le programme suivant comporte-t-il une boucle ?

1
2
3
4
5
6
7
Pensez à un nombre entier positif n.
Multipliez le nombre 1 par 2, 
multipliez le nombre obtenu (2) par 3,
multipliez le nombre obtenu (6) par 4,
etc.
multipliez le nombre obtenu par n
Vous venez de calculer la factorielle du nombre n !

Solution

Ce programme comporte une boucle. On répète une instruction (la multiplication par un nombre) un certain nombre de fois.

La condition est cachée. On continue tant que le nombre par lequel on multiplie est différent de n.

Le programme suivant comporte-t-il une boucle ?

1
2
3
4
Mettre l'eau dans le sucre et mettre le plein feu pendant 3 minutes.
À l'aide d'un thermomètre de cuisson, mesurez la température.
Si la température est supérieure à 127°C, ajoutez 50mL d'eau.
Mesurez à nouveau la température puis retirez du feu.

Solution

Ce programme ne comporte pas de boucle mais une conditionnelle. Chaque instruction est exécutée une seule fois : on remarque d'ailleurs que la seconde mesure de température ne sert à rien !

4.3 Boucles conditionnelles while⚓︎

La structure de contrôle correspondant le plus au graphe de contrôle du paragraphe 2 est la boucle conditionnelle.

Cours

En Python, la syntaxe des boucles conditionnelles est la suivante :

début code
while condition :
    bloc code A
suite code

Exemple

Tester le code ci-dessous :

i = 0bksl-nlbksl-nlwhile i <= 8:bksl-nl print(i)bksl-nl i = i + 2bksl-nlbksl-nlprint("Valeur finale de i :", i)bksl-nl

Pour vous aider à mieux comprendre : PythonTutor

Une boucle conditionnelle while nécessite donc trois éléments pour fonctionner correctement :

  • initialisation de la variable d'itération avant la boucle (ligne 1).
  • condition (expression booléenne) permettant de continuer la boucle ou non (ligne 3).
  • modification de la variable d'itération (appelé parfois incrémentation) (ligne 5).
Pour aller plus loin

Dans les langages permettant la sortie anticipée de boucle (avec break, return ou goto), les boucles conditionnelles peuvent être vues comme inutiles.

Ce n'est pas le cas des langages fonctionnels dont nous parlerons en Terminale : prenez donc l'habitude d'utiliser ces boucles conditionnelles pour ne pas dépendre du langage Python en particulier.

Manipuler des boucles conditionnelles

  • Lire le programme ci-dessous et prédire son fonctionnement.
  • Tester le programme afin de vérifier votre prédiction.

i = 1bksl-nlwhile i <= 10:bksl-nl print(i)bksl-nl i = i + 1bksl-nlbksl-nlprint("Fini")bksl-nl

Solution

Il affiche les nombres de 1 à 10 inclus. Il affiche un nombre par ligne.

À l'aide d'une boucle conditionnelle, affichez sur une seule ligne les nombres de 1 à 10 exclus.

On modifiera le programme de l'exercice précédent.

On utilisera l'option print(..., end = " ") afin d'éviter qu'un affichage nous ramène à la ligne.

benchmark = []bksl-nl 5/5
i = 1bksl-nlwhile i <= 10 :bksl-nl print(i)bksl-nl i = ......bksl-nlbksl-nlprint("Fini")bksl-nli = 1bksl-nlwhile i < 10 :bksl-nl print(i, end = " ")bksl-nl i = i + 1bksl-nlbksl-nlprint("Fini")bksl-nl

À l'aide d'une boucle conditionnelle, affichez sur une seule ligne les nombres de 10 à 1 inclus.

On s'inspirera du programme de l'exercice précédent.

On utilisera l'option print(..., end = " ") afin d'éviter qu'un affichage nous ramène à la ligne.

benchmark = []bksl-nl 5/5
i = 10bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlprint("Fini")bksl-nli = 10bksl-nlwhile i >= 1 :bksl-nl print(i, end = " ")bksl-nl i = i - 1bksl-nlbksl-nlprint("Fini")bksl-nl

  • Lire le programme ci-dessous et prédire son fonctionnement.
  • Tester le programme afin de vérifier votre prédiction.
  • Réaliser une modification simple permettant de supprimer l'instruction conditionnelle.

benchmark = []bksl-nl 5/5
i = 1bksl-nlbksl-nlwhile i <= 10:bksl-nl if i % 2 != 0:bksl-nl print(i, end = " ")bksl-nl i = i + 1bksl-nlbksl-nlprint("Fini")bksl-nli = 1bksl-nlbksl-nlwhile i <= 10:bksl-nl print(i, end = " ")bksl-nl i = i + 2bksl-nlbksl-nlprint("Fini")bksl-nlbksl-nl

Dans cet exercice, nous souhaitons programmer à la main \(2^n\).

Remarquons que : \(2^n = 1 \times 2 \times 2 \times 2 \times ...\times 2\).

Avec des parenthèses : \(2^n = (...(((1 \times 2) \times 2) \times 2) \times ...\times 2)\)

Nous devons d'abord calculer la parenthèse la plus interne (\(1 \times 2\)). Pour cela, je décide de prendre une variable appelée accumulateur = 1. En Python, cela s'écrit : accumulateur * 2. Nous référençons le résultat dans la variable accumulateur qui vaut à présent 2.

La formule devient : \(2^n = (...((\text{accumulateur} \times 2) \times ...\times 2)\). Nous pouvons réitérer l'opération et faire : accumulateur * 2. Nous référençons encore le résultat dans la variable accumulateur qui vaut à présent 4 (=\(2^2\)). Le procédé se poursuit jusqu'à ce que toutes les multiplications soient réalisées.

Compléter le programme afin qu'il calcule une puissance de 2.

benchmark = []bksl-nl 5/5
n = 10bksl-nli = 0bksl-nlaccumulateur = 1bksl-nlbksl-nlwhile ......:bksl-nl i = i + 1bksl-nlbksl-nlbksl-nl print(accumulateur)bksl-nlbksl-nlprint("2 puissance n vaut : ", accumulateur)bksl-nln = 10bksl-nli = 0bksl-nlaccumulateur = 1bksl-nlbksl-nlwhile i < n:bksl-nl i = i + 1bksl-nl accumulateur = accumulateur py-str 2bksl-nlbksl-nl print(accumulateur)bksl-nlbksl-nlprint("2 puissance n vaut : ", accumulateur)bksl-nl

Dans cet exercice, nous souhaitons programmer à la main l'opérateur multiplication ! Nous allons nous intéresser à \(a\times b\), avec b entier.

En utilisant la technique de l'accumulateur décrite dans l'exercice 10, compléter le programme ci-dessous calculant la multiplication de deux nombres a et b.

benchmark = []bksl-nl 5/5
a = 4.2bksl-nlb = 5bksl-nli = 0bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlprint(a, " ⨉ ", b, " = ", accumulateur)bksl-nla = 4.2bksl-nlb = 5bksl-nli = 0bksl-nlbksl-nlaccumulateur = 0bksl-nlbksl-nlwhile i < b:bksl-nl i = i + 1bksl-nl accumulateur = accumulateur + abksl-nlbksl-nl print(accumulateur)bksl-nlbksl-nlprint(a, " ⨉ ", b, " = ", accumulateur)bksl-nl

La suite de Syracuse est une suite d'entiers naturels définie par : \(u_{n+1}=\left \{ \begin{align} \frac{u_n}{2} & {\rm \quad si}\ u_n \rm{ \ est \ pair}\\ 3u_n +1 & {\rm \quad si}\ u_n \rm{ \ est \ impair}\\ \end{align} \right .\)

Il existe une hypothèse dite conjecture de Collatz affirmant que "Pour tout nombre entier n choisi, la suite de Syracuse se terminera sur un cycle 4, 2, 1."

Par exemple, avec \(u_0 = 6\) :

  • \(u_1 = \dfrac{6}{2} = 3\) car 6 est pair ;
  • \(u_2 = 3\times3+1 = 10\) car 3 est impair ;
  • \(u_3 = \dfrac{10}{2} = 5\) car 10 est impair ;
  • \(u_4 = 3\times 5 + 1 = 16\);
  • \(u_5 = 8\) ;
  • \(u_6 = 4\) ; \(u_7 = 2\) ; \(u_8 = 1\).

  • Écrire un programme permettant de calculer et d'afficher tous les termes de la suite de Syracuse jusqu'à la première apparition d'un 1.

  • Ajouter un compteur permettant de compter le nombre d'étapes avant l'apparition d'un 1. Ce compteur est appelé le temps de vol.
  • Quel est le temps de vol associé à \(u_0 = 15\) ?

benchmark = []bksl-nl 5/5
u = 6 # initialisationbksl-nltempspy-undvol = 0bksl-nlbksl-nl# boucle whilebksl-nl# si u divisible par 2:bksl-nl# u prend la nouvelle valeur u/2bksl-nl# sinon:bksl-nl# u prend la valeur 3 py-str u + 1bksl-nl# affichage de ubksl-nlbksl-nlbksl-nlu = 15 # initialisationbksl-nltempspy-undvol = 0bksl-nlbksl-nlwhile u != 1:bksl-nl print(u, tempspy-undvol)bksl-nl if u % 2 == 0:bksl-nl u = u // 2bksl-nl else:bksl-nl u = 3 py-str u + 1bksl-nl tempspy-undvol += 1bksl-nlbksl-nlprint(u, tempspy-undvol)bksl-nlbksl-nl

Que fait le programme suivant ?

i = 0
while i < 10:
    print('Jusque là, tout va bien.')
Solution

Ce programme affiche 'Jusque là, tout va bien.' mais ne s'arrête jamais ! En effet, la valeur de la variable de boucle n'est jamais incrémentée et n'atteint donc jamais 10.

Boucles infinies

Dans le cadre des boucles conditionnelles, la question de l'arrêt d'un programme se pose.

Il faut donc toujours se demander si notre expression booléenne sera vérifiée à un moment du programme.

Dans un éditeur de code (Thonny, VSCodium...), vous pouvez néanmoins toujours stopper l'exécution d'un script Python à l'aide de la combinaison de touches CtrlC.

4.4 Boucles inconditionnelles for⚓︎

4.4.1 Cas général⚓︎

Cours

En Python, la syntaxe des boucles inconditionnelles est la suivante :

début code
for variable_boucle in itérable :
    bloc code A
suite code

Qu'est-ce qu'un itérable ?

Pour nous, il s'agit d'une chaîne de caractères ou d'un tableau, car ceux-ci sont composés d'éléments que l'on peut épeler : la lettre ou l'élément.

Exemple 1 (important!)
  • Tester le code ci-dessous.
  • Que fait le code ? Est-ce conforme à notre définition d'un itérable ?

print('Boucle sur une chaîne de caractères')bksl-nlbksl-nlfor lettre in 'PYTHON':bksl-nl print(lettre)bksl-nlbksl-nlprint('Fin de la boucle inconditionnelle')bksl-nl

Pour vous aider à mieux comprendre : PythonTutor

Exemple 2 (important!)
  • Tester le code ci-dessous.
  • Que fait le code ? Est-ce conforme à notre définition d'un itérable ?

print("Boucle sur un tableau d'entiers")bksl-nlbksl-nlfor element in [4, 3, 8, 12, 31]:bksl-nl print(element)bksl-nlbksl-nlprint('Fin de la boucle inconditionnelle')bksl-nl

Pour vous aider à mieux comprendre : PythonTutor

Pour aller plus loin

Dans le détail, un itérable peut être créé en Python avec la fonction iter().

On itère sur l'itérable à l'aide de la fonction next().

  • Lancer le code ci-dessous et dans la console de l'éditeur ci-contre, écrire next(iterable).
  • Répéter cette commande et observer le mot en train d'être épelé. La valeur référencée par la variable lettre de la boucle for est donc définie grâce à un appel à next() d'un itérateur.
  • Remarquer l'erreur StopIteration qui apparaît une fois l'itérable complètement épelé.
  • Modifier mot ='python' en mot = 12345 et réitérer l'itération. Cela fonctionne-t-il ?

# boucle sur un itérablebksl-nlfor lettre in 'python':bksl-nl print(lettre)bksl-nlbksl-nlmot = 'python'bksl-nliterable = iter('python')bksl-nl

Application directe

  • Prédire ce que va afficher le programme ci-dessous.
  • Écrire ce programme dans l'éditeur et l'exécuter. Votre prédiction est-elle correcte ?
for lettre in '54321...':
    print(lettre)
print("Décollage")

  • Prédire ce que va afficher le programme ci-dessous.
  • Écrire ce programme dans l'éditeur et l'exécuter. Votre prédiction est-elle correcte ?
  • Modifier la ligne 3 afin d'afficher une phrase un peu plus correcte.
1
2
3
4
texte = ""
for mot in ["Les ", "chaussettes ", "sont-elles ", "sèches ?"]:
    texte = mot + texte
print(texte)

benchmark = []bksl-nl 5/5
bksl-nlbksl-nlbksl-nlbksl-nltexte = ""bksl-nlfor mot in ["Les ", "chaussettes ", "sont-elles ", "sèches ?"]:bksl-nl # Ajouter le mot à la fin du texte !bksl-nl texte = texte + motbksl-nlprint(texte)bksl-nl

Voici un tableau d'acteurs : tableau_acteurs = ['Tahar', 'Omar', 'Guillaume', 'Swann', 'Alex', 'Roschdy'].

Utiliser ce tableau pour obtenir l'affichage suivant :

Tahar a eu le César du meilleur acteur
Omar a eu le César du meilleur acteur
Guillaume a eu le César du meilleur acteur
Swann a eu le César du meilleur acteur
Alex a eu le César du meilleur acteur
Roschdy a eu le César du meilleur acteur

benchmark = []bksl-nl 5/5
tableaupy-undacteurs = ['Tahar', 'Omar', 'Guillaume', 'Swann', 'Alex', 'Roschdy']bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlfor acteur in ['Tahar', 'Omar', 'Guillaume', 'Swann', 'Alex', 'Roschdy']:bksl-nl print(acteur, "a eu le César du meilleur acteur")bksl-nl

  • Prédire ce que va afficher le programme ci-dessous.
  • Écrire ce programme dans l'éditeur et l'exécuter. Votre prédiction est-elle correcte ?
1
2
3
4
n = 3
for lettre in "abcd":
    n = n + 2
print(n)

tableaupy-undacteurs = ['Tahar', 'Omar', 'Guillaume', 'Swann', 'Alex', 'Roschdy']bksl-nlbksl-nlfor acteur in tableaupy-undacteurs:bksl-nl print(acteur, "a eu le César du meilleur acteur")bksl-nl

Remarque

On remarque qu'on vient de répéter la même opération 4 fois car l'itérable est composé de 4 lettres.

  • Exécuter ce programme ci-dessous.
  • Qu'affiche-t-il ?
  • Comprendre le fonctionnement de l'accumulateur en affichant, dans la boucle, les valeurs référencées par les variables accumulateur et mot.

benchmark = []bksl-nl 5/5
tableaupy-undmot = ["la ", "petite ", "fille ", "chante."]bksl-nlaccumulateur = "Le soir, "bksl-nlbksl-nlfor mot in tableaupy-undmot:bksl-nl accumulateur = accumulateur + motbksl-nlbksl-nlprint(accumulateur)bksl-nltableaupy-undmot = ["la ", "petite ", "fille ", "chante."]bksl-nlaccumulateur = "Le soir, "bksl-nlbksl-nlfor mot in tableaupy-undmot:bksl-nl accumulateur = accumulateur + motbksl-nlbksl-nlprint(accumulateur)bksl-nl

Aide

L'accumulateur permet d'ajouter dans une même variable plusieurs valeurs.

Cela permet donc d'accumuler des chaînes de caractères en des phrases ou plus souvent d'additionner des nombres ensemble, comme dans l'exercice suivant.

On dispose d'un tableau d'entiers : tableau = [1, 2, 3, 4, 5].

Écrire un programme qui, à l'aide d'une boucle inconditionnelle, réalise l'addition de 1, 2, 3, 4 et 5. Pensez à l'accumulateur de l'exercice 10.

benchmark = []bksl-nl 5/5
tableau = [1, 2 ,3 ,4, 5]bksl-nlaccumulateur = 0bksl-nltableau = [1, 2, 3, 4, 5]bksl-nlaccumulateur = 0bksl-nlbksl-nlfor nombre in tableau:bksl-nl accumulateur = accumulateur + nombrebksl-nl # accumulateur += nombre # fonctionne égalementbksl-nlbksl-nlprint(accumulateur)bksl-nl

Aide

Il s'agit d'utiliser une variable accumulateur qui va être initialisée à 0. On va ensuite calculer accumulateur * nombre et référencer le résultat par la variable accumulateur.

On dispose d'un tableau d'entiers : tableau = [10, 20, 30, 40]. Nous souhaitons tirer et afficher quatre nombres aléatoires entre 0 et 10, 10 et 20, 20 et 30 et 30 et 40.

Le début de programme ci-dessous vous montre comment tirer des nombres de manière aléatoire. Modifier ce programme à l'aide d'une boucle inconditionnelle for.

benchmark = []bksl-nl 5/5
import randombksl-nlbksl-nltableau = [10, 20, 30, 40]bksl-nlvaleurpy-undmini = 0bksl-nlvaleurpy-undmaxi = 10bksl-nlrandom.randint(valeurpy-undmini, valeurpy-undmaxi)bksl-nlbksl-nlvaleurpy-undmini = 10bksl-nlvaleurpy-undmaxi = 20bksl-nlrandom.randint(valeurpy-undmini, valeurpy-undmaxi)bksl-nlimport randombksl-nlbksl-nltableau = [10, 20, 30, 40]bksl-nlvaleurpy-undmini = 0bksl-nlbksl-nlfor nombre in tableau:bksl-nl valeurpy-undmaxi = nombrebksl-nl print(random.randint(valeurpy-undmini, valeurpy-undmaxi))bksl-nl valeurpy-undmini = valeurpy-undmaxibksl-nl

Aide

Remarquez que à chaque étape l'ancienne valeur maximum est devenue la valeur minimum : valeur_mini = valeur_maxi. Cela vous donne une règle à suivre dans la boucle inconditionnelle.

4.4.2 Cas de range⚓︎

Répétition d'instruction

Savoir parcourir un itérable est très pratique mais nous limite beaucoup. Souvent, nous souhaitons :

  • connaître le numéro de la lettre courante (par exemple, dans le mot "Venom", V est la lettre d'indice 0, e la lettre d'indice 1 etc.) ;
  • pouvoir répéter un nombre déterminé de fois une action.

Par exemple, dans le code ci-dessous, nous répétons une phrase 5 fois :

for i in range(5):bksl-nl print(i, "We're up all night to get lucky")bksl-nl

Cours

Un itérable occupe une place très particulière : il s'agit de range(n).

Faire parcourir à une variable k l'itérable range(n) va lui faire prendre successivement les valeurs 0, 1, 2, ..., n-1.

Lancer le programme ci-dessous :

for k in range(4):bksl-nl print("k = ", k)bksl-nlbksl-nlbksl-nlbksl-nl

Remarque

k va de 0 à n-1. Il y a donc bien n valeurs qui sont parcourues.

Lorsque l'on itère sur range, la variable de boucle est souvent nommé i, j ou k.

Manipulation de range

Faire afficher la séries de nombres ci-dessous.

On utilisera la syntaxe print(k, end = ' ') pour afficher les nombres horizontalement.

0 1 2 3 4 5

benchmark = []bksl-nl 5/5
bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlfor i in range(6):bksl-nl print(i, end = ' ')bksl-nl

Faire afficher la séries de nombres ci-dessous.

On utilisera la syntaxe print(k, end = ' ') pour afficher les nombres horizontalement.

5 6 7 8 9 10

benchmark = []bksl-nl 5/5
bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlfor i in range(6):bksl-nl print(i + 5, end = ' ')bksl-nl

Faire afficher la séries de nombres ci-dessous.

On utilisera la syntaxe print(k, end = ' ') pour afficher les nombres horizontalement.

1 4 7 10 13 16 19 22

benchmark = []bksl-nl 5/5
bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlfor i in range(8):bksl-nl print(3 py-str i + 1, end = ' ')bksl-nl

Faire afficher la séries de nombres ci-dessous.

On utilisera la syntaxe print(k, end = ' ') pour afficher les nombres horizontalement.

10 9 8 7 6 5 4 3 2 1 0

benchmark = []bksl-nl 5/5
bksl-nlfor i in range(11):bksl-nl print(10 - i, end = ' ')bksl-nl

4.4.3 Itérable ou range ?⚓︎

Comment choisir entre for i in itérable ou for i in range(n) ?

Cours

Le critère est simple :

  • si on s'intéresse au contenu d'un itérable (par exemple, aux lettres d'un mot), on va parcourir l'itérable ;
  • si on s'intéresse à du comptage ou à la position des valeurs dans l'itérable, on va utiliser range.

Itérable ou range : faites le bon choix !

Écrire un programme qui affiche les lettres du mot "Artiste".

benchmark = []bksl-nl 5/5
bksl-nlfor lettre in 'Artiste':bksl-nl print(lettre)bksl-nl

Écrire un programme qui affiche la table de multiplication de 7. On obtiendra l'affichage suivant :

7 x 0 = 0
7 x 1 = 7
...
7 x 10 = 70

benchmark = []bksl-nl 5/5
bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlfor k in range(11):bksl-nl print(k, ' x ', 7, ' = ', 7 py-str k)bksl-nl

Écrire un programme qui affiche In the castle of AAAAArrrrrggggghhhhh. On pourra partir du mot 'Argh' où l'on répétera 5 fois chaque lettre.

benchmark = []bksl-nl 5/5
phrase = 'In the castle of 'bksl-nlbksl-nlbksl-nlprint(phrase)bksl-nlphrase = 'In the castle of 'bksl-nlmot = ''bksl-nl# aucune raison d'utiliser range : bksl-nlfor lettre in 'Argh':bksl-nl mot = mot + lettre py-str 5bksl-nlbksl-nlphrase = phrase + motbksl-nlprint(phrase)bksl-nlbksl-nlbksl-nl

4.5 Boucles imbriquées⚓︎

Cours

Il est très souvent utile d'imbriquer une boucle dans une autre, notamment lors du parcours de tous les pixels d'une image.

Exemple

for a in range(5):bksl-nl for b in range(4):bksl-nl p = a py-str bbksl-nl print(a, 'py-str', b, '=', p, end = ', ')bksl-nl print()bksl-nl

4.6 Exercices récapitulatifs⚓︎

Cours

On utilise une boucle conditionnelle quand on ne connaît pas à l'avance le nombre de répétitions.

On utilise une boucle inconditionnelle quand on veut épeler des éléments un à un ou que l'on connaît le nombre de répétitions à effectuer,

Exercice 28

Sur un jeu d'échecs, les cases sont repérées par une lettre (de A jusqu'à H) et par un chiffre (de 1 jusqu'à 8).

Les cases sont donc A1, A2, A3, ..., H7, H8.

Proposer un code qui affiche toutes les cases possibles.

benchmark = []bksl-nl 5/5
for lettre in "ABCDEFGH":bksl-nl bksl-nl bksl-nlbksl-nl print()bksl-nlfor lettre in "ABCDEFGH":bksl-nl for chiffre in range(8):bksl-nl case = lettre + str(chiffre + 1)bksl-nl print(case, end = ' ')bksl-nl print()bksl-nl

Exercice 29

En Python, la fonction ord renvoie le code Unicode d'un caractère et la fonction chr le contraire: elle renvoie le caractère correspondant à un code Unicode.

Par exemple:

>>> ord('a')
97
>>> chr(97)
'a'

Voici une liste contenant les codes Unicode des lettres d'un mot secret... Écrire un programme où en sortie, la variable mot_secret contiendra la chaîne de caractères de ce mot.

benchmark = []bksl-nl 5/5
mystere = [111, 107, 44, 32, 98, 105, 101, 110, 32, 106, 111, 117, 233]bksl-nlmotpy-undsecret = ""bksl-nlmystere = [111, 107, 44, 32, 98, 105, 101, 110, 32, 106, 111, 117, 233]bksl-nlmotpy-undsecret = ""bksl-nlbksl-nlfor nombre in mystere:bksl-nl lettre = chr(nombre)bksl-nl motpy-undsecret = motpy-undsecret + lettrebksl-nlbksl-nlprint(motpy-undsecret)bksl-nl

Exercice 30

On imagine une puce qui se déplace aléatoirement sur une ligne, en avant ou en arrière, par pas de 1 ou -1.

Par exemple :

  • si elle est à l'emplacement 0, elle peut sauter à l'emplacement 1 ou -1 ;
  • si elle est à l'emplacement 2, elle peut sauter à l'emplacement 3 ou 1.

Avec la boucle de votre choix, simuler le mouvement de cette puce de l'emplacement initial 0 à l'emplacement final 5 (voir le schéma de la figure).

Afficher le nombre de sauts nécessaires pour réaliser ce parcours.

Relancer plusieurs fois le programme. Trouve-t-on le même nombre de sauts à chaque exécution ?

sauts-de-puce

Générer des nombres aléatoires

Afin de générer des nombres aléatoires, nous importons le module random. Le programme proposé utilise également l'instruction random.choice([-1, 1]) qui renvoie au hasard la valeur -1 ou 1 avec une probabilité \(\dfrac{1}{2}\).

Nous reverrons la signification de cette syntaxe particulière dans le chapitre sur la modularité.

benchmark = []bksl-nl 5/5
import randombksl-nlbksl-nldépart = 0bksl-nlarrivée = 5bksl-nlnombrepy-undsauts = 0bksl-nlbksl-nlbksl-nlbksl-nlbksl-nlprint(nombrepy-undsauts)bksl-nlimport randombksl-nlbksl-nldépart = 0bksl-nlarrivée = 5bksl-nlbksl-nlpositionpy-undpuce = départbksl-nlnombrepy-undsauts = 0bksl-nlwhile positionpy-undpuce != arrivée:bksl-nl positionpy-undpuce = positionpy-undpuce + random.choice([-1, 1])bksl-nl nombrepy-undsauts += 1 # ou nombrepy-undsauts = nombrepy-undsauts + 1bksl-nlbksl-nlprint(nombrepy-undsauts)bksl-nl

Résumé

Dans ce chapitre, j'ai appris :

  • l'intérêt des boucles dans la cadre du principe DRY ;
  • l'existence de boucles conditionnelles et inconditionnelles ;
  • comment utiliser les boucles conditionnelles ;
  • comment parcourir les valeurs d'un itérable avec une boucle inconditionnelle ;
  • comment parcourir les indices d'un itérable avec une boucle inconditionnelle.
Retour en haut de la page