{
"cells": [
{
"cell_type": "markdown",
"id": "experimental-referral",
"metadata": {},
"source": [
"# TD - Les boucles"
]
},
{
"cell_type": "markdown",
"id": "alive-youth",
"metadata": {},
"source": [
"## 1. Définition\n",
"\n",
"Souvent, dans un programme, il est nécessaire de répéter un certain nombre de fois une (ou des) instruction(s). Pour cela, on utilise ce qu'on appelle des __boucles__."
]
},
{
"cell_type": "markdown",
"id": "romance-grounds",
"metadata": {},
"source": [
"### 1.1. Exemple introductif\n",
"\n",
"Le nombre d'utilisateurs d'un nouveau réseau social _KILESTBIEN_ est égal à 500 000 en janvier 2020. Ce nombre augmente de 5 % par mois, donc est multiplié par 1.05 chaque mois. Si on veut connaître le nombre d'utilisateurs 10 mois plus tard, il faut effectuer 10 fois de suite le même calcul (une multiplication par 1.05)."
]
},
{
"cell_type": "markdown",
"id": "controlled-construction",
"metadata": {},
"source": [
"### 1.2. À Faire \n",
"\n",
"Compléter le programme Python suivant afin d'obtenir le nombre d'utilisateurs du réseau _KILESTBIEN_ au bout de 10 mois.\n",
"\n",
"```python\n",
"nb_utilisateurs = 500000\n",
"nb_utilisateurs = nb_utilisateurs * 1.05\n",
"???\n",
"print(???)\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "awful-usage",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "related-harmony",
"metadata": {},
"source": [
"### 1.3. Problématique\n",
"\n",
"Des banquiers veulent investir 1 million d'euros dans _KILESTBIEN_, mais ont une exigence. Ils souhaitent que le nombre d'utilisateurs du réseau soit au moins de 3 millions dans 3 ans.\n",
"\n",
"Selon le taux de croissance du nombre d'utilisateurs de 5% par mois, vont-ils investir dans _KILESTBIEN_ ? Que faut-il modifier dans le programme précédent pour répondre à cette question ?"
]
},
{
"cell_type": "markdown",
"id": "representative-vertical",
"metadata": {},
"source": [
"## 2. Boucles bornée\n",
"\n",
"Au lieu d'écrire 10 ou 36 lignes identiques il est préférable d'écrire une seule fois cette ligne et d'indiquer de l'exécuter 10 ou 36 fois : pour cela, on utilise une __boucle bornée__. En Python, au lieu d'écrire le programme du 1. À Faire, il est possible d'écrire :\n",
"\n",
"```python\n",
"nb_utilisateurs = 500000\n",
"for i in range(10):\n",
" nb_utilisateurs = nb_utilisateurs * 1.05\n",
"print(nb_utilisateurs)\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "czech-andrews",
"metadata": {},
"source": [
"### 2.1. Construction d'une boucle bornée\n",
"\n",
"Pour écrire une boucle bornée en Python on utilise le mot-clé `for`. Les boucles bornées sont par conséquent très souvent appelées *boucles for* (ou *boucles pour* en français)."
]
},
{
"cell_type": "markdown",
"id": "olympic-winner",
"metadata": {},
"source": [
"### 2.2. Utilisation de la fonction `range()`\n",
"\n",
"- La fonction `range` permet de générer un intervalle sous la forme d'une liste d'entiers. Par exemple, l'appel `range(n)` génère $n$ entiers : $0, 1, 2, ..., n-1$. \n",
"- ⚠ Attention : comme le premier entier est 0, le n-ième est numéroté $n - 1$.\n",
"- La variable notée `i` prendra successivement (à chaque tour de boucle) les valeurs générées par la fonction `range`. Ici, `i` prendra les valeurs 0 puis 1 puis 2, ..., puis $n - 1$.\n",
"- Le bloc d'instructions à répéter doit être indenté (d'une tabulation) et sera donc ici exécuté $n$ fois."
]
},
{
"cell_type": "markdown",
"id": "searching-journal",
"metadata": {},
"source": [
"#### 2.2.1. À Faire\n",
"\n",
"On considère le programme Python suivant.\n",
"\n",
"```python\n",
"a = 2\n",
"for i in range(4):\n",
" a = a + 1\n",
" print(a)\n",
"```\n",
"\n",
"1. Quel est le bloc d'instructions répété dans la boucle `for` ?\n",
"2. Combien de fois est-il répété ?\n",
"3. Combien de valeurs sont affichées au cours de l'exécution de ce programme ?\n",
"4. Quelle est la valeur finale de la variable `a` ?"
]
},
{
"cell_type": "markdown",
"id": "broke-warrant",
"metadata": {},
"source": [
"#### 2.2.2. À Faire\n",
"\n",
"On considère le programme Python suivant :\n",
"\n",
"```python\n",
"a = 1\n",
"b = 5\n",
"for i in range(3):\n",
" a = 2 * a\n",
" b = b + a\n",
"print(b)\n",
"```\n",
"\n",
"On va commencer par analyser le code pour le comprendre.\n",
"\n",
"1. Quel est le bloc d'instructions répété dans la boucle `for` ? Combien de fois est-il répété ?\n",
"2. Expliquez pourquoi il n'y a qu'une seule valeur qui s'affiche dans la console si on exécute le code ?\n",
"3. Recopiez et complétez le tableau ci-dessous avec les valeurs des variables `i`, `a` et `b` à chaque tour de boucle.\n",
"\n",
"| `i` | `a` | `b` |\n",
"| :--: | :--: | :---: |\n",
"| | 1 | 5 |\n",
"| 0 | ??? | ??? |\n",
"| ??? | ??? | ??? |\n",
"| ??? | ??? | ??? |\n",
"\n",
"4. Quelle est la valeur finale de la variable `b` ?\n",
"5. Exécutez ensuite le code et vérifiez ce qu'il produit."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "danish-oxide",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "strategic-mason",
"metadata": {},
"source": [
"## 3. Exercices"
]
},
{
"cell_type": "markdown",
"id": "artificial-water",
"metadata": {},
"source": [
"### Exercice 1 - La punition\n",
"\n",
"L'article 2.2 Les punitions scolaires d'une circulaire ministérielle du 13 Juillet 2000 rappelle qu' « _Il convient également de distinguer soigneusement les punitions relatives au comportement des élèves de l'évaluation de leur travail personnel. Ainsi n'est-il pas permis de baisser la note d'un devoir en raison du comportement d'un élève ou d'une absence injustifiée. Les __lignes et les zéros doivent également être proscrits__._»\n",
"\n",
"Votre professeur était élève bien avant cette circulaire et a souvent été puni avec pour sanction le fait de devoir copier 100 fois sur une feuille la phrase suivante : \"_Je ne discuterai plus avec mon camarade de classe pendant les cours_.\"\n",
"\n",
"Écrire un programme Python qui permet de facilement transcire la punition."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "frozen-cherry",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "daily-richards",
"metadata": {},
"source": [
"### Exercice 2 - Table de Multiplication\n",
"\n",
"1. Recopiez le programme suivant :\n",
"\n",
"```python\n",
"nombre = int(input(\"De quel nombre voulez-vous la table de multiplication ? \"))\n",
"\n",
"for compteur in range(10):\n",
"\tprint(nombre)\n",
"```\n",
"\n",
"2. Modifiez ce programme pour qu'il affiche la table de multiplication du nombre demandé, de 0 à 10. Par exemple, si l'utilisateur donne la valeur 6, le programme devrait afficher : 0, 6, 12, 18, …, 60."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "adjustable-serum",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "derived-perfume",
"metadata": {},
"source": [
"### Exercice 3 - Problème de l'échiquier de Sissa\n",
"\n",
"Selon [la légende](https://fr.wikipedia.org/wiki/Problème_de_l'échiquier_de_Sissa), pour remercier l'inventeur des échecs Sissa, le roi lui demanda de choisir sa récompense. Sissa demanda alors du riz : __un grain sur la première case, deux grains sur la seconde case, quatre grains sur la troisième case, huit grains sur la quatrième, et ainsi de suite jusqu'à la dernière case du jeu d'échec__. Le roi accepta.\n",
"\n",
"On se demande combien de grains seront posés sur la dernière case du plateau d'échecs (qui en compte 64).\n",
"\n",
"Pour résoudre ce problème, on peut utiliser le programme suivant :\n",
"\n",
"```python\n",
"grains = 1\n",
"\n",
"for compteur in range(???):\n",
" grains = ???\n",
"\n",
"print(\"Nombre de grains sur la dernière case :\", grains)\n",
"```\n",
"\n",
"1. Compléter ce programme, et exécutez-le.\n",
"2. Combien de grains de riz y aura-t-il sur la dernière case de l'échiquier ?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "breeding-stack",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "north-diabetes",
"metadata": {},
"source": [
"### Exercice 4 - Petite tortue qui dessine\n",
"\n",
"Le module `turtle` (*tortue*) permet de dessiner avec Python.\n",
"\n",
"Dans cet exercice on veut écrire un programme qui permet de dessiner des formes géométriques. Voici le code incomplet du programme.\n",
"\n",
"```python\n",
"import turtle # pour utiliser le module turtle\n",
"\n",
"\"\"\"Fonction qui dessine un carré de coté 100 pixels\"\"\"\n",
"turtle.forward(100) # pour avancer de 100 pixels\n",
"turtle.left(90) # pour tourner de 90° à gauche\n",
"turtle.forward(100)\n",
"turtle.left(90)\n",
"# À Compléter\n",
"\n",
"turtle.done() # pour afficher le dessin\n",
"```\n",
"1. Modifiez le programme afin que la tortue dessine un `carré`, en utilisant une boucle `for`.\n",
"2. Modifiez le programme afin que la tortue dessine un `triangle`, en utilisant une boucle `for`.\n",
"3. Modifiez le programme afin que la tortue dessine un `octogone`, en utilisant une boucle `for`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bacterial-hamburg",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "informative-insulation",
"metadata": {},
"source": [
"## 4. Boucle bornée avec le mot-clé `in`\n",
"\n",
"Comme on l'a vu précédemment, il est possible de créer une boucle bornée en utilisant le mot-clé `in` associé au mot clé `range`. Cela permet de répéter les mêmes instructions sur un intervalle.\n",
"\n",
"Cette section va nous permettre de voir une autre utilisation de la boucle bornée. En effet, il est possible d'itérer sur tous les éléments de certaines variables en utilisant le mot clé `in` de la façon suivante :\n",
"\n",
"```python\n",
"for element in variable: # se traduit pas \"pour chaque element de variable\"\n",
" bloc_instructions\n",
"```\n",
"\n",
"**Remarques** :\n",
"\n",
"- `variable` peut être une chaîne de caractères (type `str`) ou une liste (type `list`).\n",
"- Dans ce cas, la variable `element` prend successivement chacune des valeurs de `variable`."
]
},
{
"cell_type": "markdown",
"id": "acquired-reset",
"metadata": {},
"source": [
"### 4.1. À Faire\n",
"\n",
"1. Copier et exécuter le code suivant.\n",
"```python\n",
"a = \"SNT\"\n",
"for lettre in a:\n",
"\tprint(lettre)\n",
"```\n",
"2. Quel est le résultat obtenu ?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "capital-minnesota",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "human-accommodation",
"metadata": {},
"source": [
"## 5. Compléments sur la fonction range\n",
"\n",
"Dans les paramètres de la fonction `range` il est également possible de préciser une première valeur (si on ne veut pas commencer à zéro) ainsi que le pas (si on ne veut pas que les itérations se fassent de 1 en 1).\n",
"\n",
"Après avoir regardé la [vidéo](https://www.youtube.com/watch?v=07IGOcpiE7o), répondez aux questions qui suivent. Vous vérifierez ensuite en utilisant un éditeur de code Python."
]
},
{
"cell_type": "markdown",
"id": "phantom-presentation",
"metadata": {},
"source": [
"1. Quelles sont les valeurs affichées dans la console lors de l'exécution de chacun des programmes ci-dessous ? *Attention, il faut répondre sans exécuter le code !*\n",
"\n",
"2. - Programme 1 :\n",
"\n",
" ```python\n",
" for i in range(10):\n",
" print(i)\n",
" ```\n",
" - Programme 2 :\n",
"\n",
" ```python\n",
" for k in range(2, 10):\n",
" print(k)\n",
" ```\n",
" - Programme 3 :\n",
"\n",
" ```python\n",
" for ind in range(2, 10, 3):\n",
" print(ind)\n",
" ```\n",
"\n",
"3. Exécutez successivement les trois codes et vérifiez vos réponses à la question précédente."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "saving-conducting",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.6"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
