{ "cells": [ { "cell_type": "markdown", "metadata": { "toc": true }, "source": [ "

Table of Contents

\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "

La boucle \"pour\"

\n", "La boucle pour est utilisée quand on connait le nombre de fois où l'on doit répéter une suite d'instructions.\n", "\n", "

Structure de la boucle \"pour\" en pseudo code :

\n", "
\n", "

Pour i allant de 0 à n-1\n", "
  faire :\n", "
    ...\n", "
    les différentes instructions à répéter\n", "
    ... \n", "
Fin pour\n", "

\n", "
\n", "Pour illustrer ce cours nous allons partir sur un premier exemple : Obtenir la somme des n premiers entiers naturels.\n", "
Pour n=4, on veut écrire un programme qui renvoie la valeur de 0+1+2+3=6.\n", "\n", "

Ecriture du programme de l'exemple en pseudo code :

\n", "\n", "

    \n", "
  1. S← 0\n", "
  2. Pour i allant de 0 à n-1\n", "
  3.   faire :\n", "
  4.     S ← S+i\n", "
  5. Fin pour\n", "

\n", "\n", "\n", "

La structure de la boucle \"pour\" en python

\n", "
La première ligne fait que la suite du code va être répétée n fois en incrémentant de manière automatique la variable i de 0 à n-1.\n", "
Dans un premier temps l'attribut dans `range` sera un entier, nous verrons dans la suite qu'il peut en être autrement.\n", "
\n", "
for i in range(n): \n", "
    ...\n", "
    les différentes instructions à répéter\n", "
    ... \n", "
\n", " On remarque ici l'absence de \"faire\" et de \"fin pour\". C'est en fait l'indentation qui sert de limitateur de boucle. L'indentation en python n'est pas uniquement un élèment d'hygiène de programmation mais un élément faisant partie intégrante des structures.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "

Ecriture du programme de l'exemple en python :

\n", " " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "190" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def somme(n:int)->int: #les int sont ici pour indiquer le typage des variables d'entrée et de sortie. Ici l'attribut est de type int et la sortie également \n", " \"\"\"\"\"La fonction somme renvoie la somme des n+1 premiers entiers naturels.\n", " la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S\n", " Pour n=4 : S=0+1+2+3=10\"\"\"\"\" \n", " S=0 #initialisation de la somme à 0\n", " for i in range(n):\n", " \n", " S=S+i\n", " return S\n", "somme(20)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "190" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "somme(20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Cliquer sur cette adresse : http://pythontutor.com/visualize.html#mode=edit\n", "
Copier/coller votre code dans la fenêtre\n", "
puis cliquer sur `Visualize Execution` pour observer la trace d'exécution de votre code pas à pas puis par des clics succéssifs sur le bouton `forward`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercices

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "
Modifier la fonction `somme(n)` pour qu'en sortie on ait la somme des n+1 premiers entiers naturels.\n", "
pour n=4, S=0+1+2+3+4=10" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "\n", "def somme(n:int)->int: #les int sont ici pour indiquer le typage des variables d'entrée et de sortie. Ici l'attribut est de type int et la sortie également \n", " \"\"\"\"\"La fonction somme renvoie la somme des n+1 premiers entiers naturels.\n", " la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S\n", " Pour n=4 : S=1+2+3+4=10\"\"\"\"\" \n", " S=0 #initialisation de la somme à 0\n", " for i in range(n): \n", " S=S+i\n", " return S" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#test de la fonction somme avec l'attribut 4\n", "somme(4) #la réponse doit être 10\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "Ecrire une fonction `TableMulti()` qui reçoit en entrée un nombre entier `n` compris entre 1 et 10 et affiche en sortie la table de\n", "multiplication de ce nombre. Par exemple, si l’algorithme reçoit en entrée le nombre 7, il affichera la table de multiplication.\n", "
1 fois 7 = 7\n", "
2 fois 7 = 14\n", "
3 fois 7 = 21\n", "
etc..." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "La multiplication de 5 par 8 est 40\n" ] } ], "source": [ "#Aide à l'affichage du résultat:\n", "i=5\n", "n=8\n", "print(\"La multiplication de\", i, \"par\", n, \"est\",i*n )" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def tableMulti(n:int)->None:\n", " \"\"\"Renvoie la table de multiplcation de n\"\"\"\n", " \n", " return None" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#test de la fonction :\n", "tableMulti(5)\n", "tableMulti(9)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "A la naissance d'Apolline, son grand-père Joël, lui ouvre un compte bancaire. Ensuite, à chaque anniversaire, le\n", "grand père d'Apolline verse sur son compte 100 €, auxquels il ajoute le double de l’âge d'Apolline.\n", "
Par exemple, lorsqu’elle a deux ans,\n", "il lui verse 104 € ce qui lui fait un total de 100+102+104=306 € à la deuxième année.\n", "
Ecrire une fonction `TresorApo()` qui en entrée reçoit un entier `n` et en sortie la somme présente sur le compte d'Apolline à sa nième année." ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [], "source": [ "def tresorApo(n:int)->int:\n", " \n", " return tresor" ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1210" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#teste de la fonction :\n", "tresorApo(2) #la valeur de sortie doit être 306\n", "tresorApo(10) #la valeur de sortie doit être 1210" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "L'instruction `range` peut prendre différents attributs. Dans cet exercice nous allons utiliser l'instruction :\n", "
\n", "`for i in range(depart,arrivée,pas):`\n", "
\n", "qui permet de repéter la boucle et d'incrémenter `i` de `départ` à `arrivée-1` avec une incrémentation de `pas`.\n", "
Les finances de Joël ne sont pas au mieux, il décide de ne donner à Apolline qu'une année sur deux en conservant la même règle.\n", "
A deux ans Apolline aura donc :100+104=204 €\n", "
Reprendre l'énoncé de l'exercice I.5.3 en écrivant une fonction `tresorApoB()` qui prend en entrée un entier `n` et renvoie un entier.\n" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [], "source": [ "def tresorApoB(n:int)->int:\n", " \n", " return tresor" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "204" ] }, "execution_count": 104, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Test de la fonction\n", "tresorApoB(3) #la valeur de sortie doit être 204\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "
Dans cet exercice nous allons donner à l'instruction `range` un attribut de type `list`.\n", "
Nous allons écrire une fonction `estDansListe` qui prend en entrée une liste `lst` et un entier `n` et qui renvoie `True` si l'entier est dans la liste et `False` sinon.\n", "
Pour cela nous allons utiliser l'instruction :\n", "
\n", "`for i in lst:`\n", "
\n", "
Qui va répéter les instructions autant de fois que d'éléments dans la liste et qui à chaque étape va donner à `i` une valeur de la liste `lst` en commençant par la première.\n", "
Indication : Vous devez utiliser une boucle conditionnelle \"Si\"" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "def estDansListe(lst:list,n:int)->bool:\n", " test=False\n", " \n", " return test" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#test de la fonction\n", "l=[0,1,2,3,4,5]\n", "estDansListe(l,8) #doit renvoyer False\n", "estDansListe(l,5) #doit renvoyer True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

La boucle \"tant que\"

\n", "La boucle \"tant que \" est utilisée quand on ne connait pas le nombre de fois où l'on doit répéter une suite d'instructions.
Elle est souvent utilisée également pour remplacer une boucle dans un souci d'optimisation du code. \n", "
Une autre différence majeure avec la boucle pour est l'absence d'incrémentation automatique.\n", "\n", "

Structure de la boucle \"tant que\" en pseudo code :

\n", "
\n", "

Tant que \"condition : booléen\"\n", "
  faire :\n", "
    ...\n", "
    les différentes instructions à répéter\n", "
    ... \n", "
Fin pour\n", "

\n", "
\n", "Pour illustrer ce cours nous allons partir sur le premier exemple vu précédemment: Obtenir la somme des n premiers entiers naturels\n", " Pour n=4, on veut écrire un programme qui renvoie la valeur de 0+1+2+3=6.\n", "\n", "

Ecriture du programme de l'exemple en pseudo code :

\n", "\n", "

  1. S← 0\n", "
  2. i← 0\n", "
  3. Tant que i<4\n", "
  4.   faire :\n", "
  5.     i ← 1+i\n", "
  6.     S ← S+i \n", "
  7. Fin tant que\n", "

\n", "\n", "\n", "

La structure de la boucle \"tant que\" en python

\n", "
La première ligne fait que les instructions dans la boucle vont être répétées tant que les conditions indiquées derrière le `while` sont vérifiées.\n", "
L'écriture des conditions est ici simple, elle peut être composée de plusieurs conditions. Cela offre des possibilités de codes intéressantes et parfois complexes.\n", "
Remarque : Dans les premiers exemples la condition est simple et on pourrait remplacer cette boucle `while` par une boucle `for`.\n", "
\n", "
While i<4:\n", "
    ...\n", "
    les différentes instructions à répéter\n", "
    ... \n", "
\n", " On remarque ici l'absence de \"faire\" et de \"fin tant que\". Comme pour la boucle pour c'est en fait l'indentation qui sert de limitateur de boucle. On rappelle encore que l'indentation en python n'est pas uniquement un élèment d'hygiène de programmation mais un élément faisant partie intégrante des structures." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "

Ecriture du programme de l'exemple en python :

" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "def somme(n:int)->int: \n", " \"\"\"\"\"La fonction somme renvoie la somme des n+1 premiers entiers naturels.\n", " la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S\n", " Pour n=4 : S=0+1+2+3=10\"\"\"\"\" \n", " S=0 #initialisation de la somme à 0\n", " i=0\n", " while iCliquer sur cette adresse : http://pythontutor.com/visualize.html#mode=edit\n", "
Copier/coller votre code dans la fenêtre\n", "
puis cliquer sur `Visualize Execution` pour observer la trace d'exécution de votre code pas à pas puis par des clics succéssifs sur le bouton `forward`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercices

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "
Modifier la fonction `somme(n)` pour qu'en sortie on ait la somme des n+1 premiers entiers naturels.\n", "
pour n=4, S=0+1+2+3+4=10" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "def somme(n:int)->int: \n", " \"\"\"\"\"La fonction somme renvoir la somme des n+1 premiers entiers naturel.\n", " la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S\n", " Pour n=4 : S=0+1+2+3+4=10\"\"\"\"\" \n", " S=0 #initialisation de la somme à 0\n", " i=1\n", " while iExercice\n", "
Une entreprise vend un récupérateur d'eau de pluie qui a une capacité de 150 litres d'eau.\n", "
Elle voudrait proposer à ses clients un programme qui permettrait au client de savoir en combien de jours le réservoir sera plein en fonction du remplissage moyen quotidien.\n", "
Ecrire une fonction `full` qui prend en argument une entrée du type `float` indiquant le volume en litre du remplissage moyen quotidien `a` et en sortie un entier indiquant le nombre de jours nécessaire au remplissage." ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [], "source": [ "def full(a:float)->int:\n", "\n", " return #test de la fonction\n" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "49" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#test de la fonction\n", "full(3.1) #la réponse devrait être 49" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "
Ecrire une fonction qui permet d'écrire une liste d'entiers aléatoires qui s'arrête dès que la somme des nombres dépasse une certaine valeur.\n", "
la fonction `makeList` prend en entrée 3 valeurs entières `deb`, `fin` et `max` correspondant respectivement à la plus petite valeur des nombres aléatoires, à la plus grande et à la valeur à ne pas dépasser en faisant la somme de ces nombres." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "#à interpréter en premier\n", "from random import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Des instructions nécessaires à la réalisation du programme :" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "17" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#obtenir un nombre entre deux entiers, 10 et 25 par exemple\n", "randint(10,25)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5]\n" ] } ], "source": [ "#pour créer une liste vide qui s'appelle lst on écrit :\n", "lst=[]\n", "#pour rajouter un élément à cette liste par exemple 5 on écrit :\n", "lst.append(5)\n", "print(lst)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "def makeList(deb:int,fin:int,max:int)->list:\n", " \n", " return " ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3, 29, 16, 15, 13, 36, 2, 25, 36, 10, 39, 49]" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "makeList(2,50,250)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "Reprendre l'exercice 1.5.5 en utlisant une boucle while" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l=[0,1,2,3,4,5]\n", "#Pour déterminer la longueur d'une liste on écrit :\n", "len(l)\n" ] }, { "cell_type": "code", "execution_count": 112, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Attention aux indices !\n", "l[5]" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [], "source": [ "def estDansListe(lst:list,n:int)->bool:\n", "\n", " return " ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 115, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#test de la fonction\n", "l=[0,1,2,3,4,5]\n", "estDansListe(l,8) #doit renvoyer False\n", "estDansListe(l,5) #doit renvoyer True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "Écrire une fonction qui demande à l'utilisateur d'entrer des notes, sans que l'on sache à l'avance combien de\n", "notes il va saisir : l'arrêt de la saisie se produit dès que l'utilisateur saisit un nombre négatif.\n", "
Le programme doit calculer et afficher la moyenne (Attention: le nombre négatif saisi ne doit pas compter dans la\n", "moyenne !). \n", "On nommera cette fonction `moy` elle ne prendra aucune entrée et donnera un élément de type `float` en sortie." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#demander au joueur un nombre et l'affecter à une variable :\n", "a=input(\"Donner un nombre\")\n", "print(a)\n", "#la valeur renvoyée par input est de type str, il faudra donc écrire :\n", "a=int(input(\"Donner un nombre\"))" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [], "source": [ "def moy()->float:\n", " \n", " return " ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donner une note10\n", "Donner une note12\n", "Donner une note14\n", "Donner une note8\n", "Donner une note12\n", "Donner une note6\n", "Donner une note8\n", "Donner une note-1\n", "la moyenne de la liste des notes : [10, 12, 14, 8, 12, 6, 8] est 10.0\n" ] } ], "source": [ "#test de la fonction\n", "# essayer 10,12,14,8,12,6,8\n", "#la sortie devrait être 10\n", "moy()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "
Pour commencer l'ordinateur va choisir au hasard un nombre compris entre 1 et 100.\n", "
L'utilisateur doit alors deviner ce nombre comme ceci :\n", "
L'utilisateur propose un nombre. L'ordinateur lui dit s'il est trop petit ou trop grand, et ainsi de suite jusqu'à ce que l'utilisateur ait trouvé le bon nombre." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Des instructions nécessaires à la réalisation du programme :" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "#la condition n'est pas égale s'écrit :\n", "!=\n", "#le test d'égalité s'écrit :\n", "==" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ecrire la fonction `plusOuMoins()` qui en entrée ne reçoit rien et en sortie renvoie le nombre d'essais qu'il a fallu pour trouver l'entier." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def pluOuMoins()->str:\n", "\n", " return None\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donner un entier entre 1 et 10050\n", "85\n", "La réponse est supérieure à ta propositon. Essaie encore !85\n", "Gagné\n" ] } ], "source": [ "#tester le programme\n", "pluOuMoins()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice

\n", "On reprend l'exercice précédent en ajoutant une règle. Vous devez ajouter une entrée `nbEssais` de type int à la fonction qui correspond au nombre d'essais maximum.\n", "On nommera cette fonction `plusOuMoinB`" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "def plusOuMoinB(nbEssais:int)->str:\n", " \n", " return \n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donner un entier entre 1 et 10050\n", "65\n", "La réponse est supérieure à ta propositon. Essaie encore !60\n", "La réponse est supérieure à ta propositon. Essaie encore !65\n", "Gagné en 3 essais\n" ] } ], "source": [ "plusOuMoinB(10)" ] } ], "metadata": { "hide_input": false, "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.7.3" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": true, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": true, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }