{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TD - Les instructions conditionnelles\n",
    "\n",
    "> « _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film \"La Guerre des boutons\" d'Yves Robert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Définition\n",
    "\n",
    "> Une __instruction conditionnelle__ permet de faire des choix en fonction de la valeur d’une __condition__. On parle souvent d’une instruction _si-alors_, ou _if-else_ en anglais.\n",
    "\n",
    "En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».\n",
    "\n",
    "> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.\n",
    "\n",
    "Par exemple, si une variable `note_francais` vaut 5 et qu’une variable `note_anglais` vaut 10 alors la condition `note_francais < note_anglais` est une condition qui est vraie, tandis que les conditions `note_francais > note_anglais` et `note_francais == note_anglais` sont fausses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Comparaisons de variables\n",
    "\n",
    "Les opérateurs de comparaisons sont :\n",
    "\n",
    "- `<` : inférieur\n",
    "- `<=` : inférieur ou égal\n",
    "- `>`: supérieur\n",
    "- `>=`: supérieur ou égal\n",
    "- `==` : est égal à\n",
    "- `!=`: est différents de\n",
    "\n",
    "Le résultat d'une comparaison est toujours un booléen\n",
    "\n",
    "- `True` si la comparaison est vraie\n",
    "- `False` si la comparaison est Fausse\n",
    "\n",
    "Remarque : on ne peut comparer que des objets comparables\n",
    "\n",
    "⚠ ___ATTENTION___ : le test d'égalité entre deux variables se fait avec un double égal `==` (car le simple `=` permet d'affecter une valeur à une variable, Cf. Activité 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 À faire\n",
    "\n",
    "1. Déterminer (sans les exécuter) chaque instruction ci-dessous :\n",
    "\n",
    "```python\n",
    ">>> a = 5\n",
    ">>> b = 18 \n",
    ">>> c = 12.3\n",
    ">>> mot1 = \"Hello\"\n",
    ">>> mot2 = \"World\"\n",
    "# \n",
    ">>> print(a > b)\n",
    "#\n",
    ">>> print(b // a == 3)\n",
    "#\n",
    ">>> print(b % a == 3)\n",
    "#\n",
    ">>> print(a - b > 2)\n",
    "#\n",
    ">>> print(type(c) == float)\n",
    "#\n",
    ">>> print(mot1 != mot2)\n",
    "#\n",
    ">>> print(mot1 < mot2)\n",
    "#\n",
    ">>> print(mot1 > 2)\n",
    "```\n",
    "\n",
    "2. Vérifier les résultats attendus avec les résultats constatés"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans une suite d'instructions on est souvent amené à faire des choix.\n",
    "\n",
    "## 3. Cas : Si...Alors\n",
    "\n",
    "**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions\n",
    "\n",
    "La structure en Python : On __indente__ (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée\n",
    "\n",
    "```\n",
    "if condition :\n",
    "    instruction1\n",
    "    instruction2\n",
    "```\n",
    "\n",
    "Exemple qui affiche si les variables `a` et `b` sont des entiers pairs\n",
    "\n",
    "```python\n",
    "a = 12\n",
    "if a % 2 == 0:\n",
    "    print(a, \" est un entier pair\")\n",
    "    \n",
    "b = 13\n",
    "if b % 2 == 0:\n",
    "    print(b,\" est un entier pair\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Cas : Si ...Alors...Sinon\n",
    "\n",
    "Dans cette structure, si la ou les conditions sont vraies, les instructions 1 et 2 sont exécutées. Sinon c'est l'instruction3 qui est exécutée.\n",
    "\n",
    "```\n",
    "    if condition:\n",
    "        instruction1\n",
    "        instruction2\n",
    "    else:\n",
    "        instruction3\n",
    "```\n",
    "\n",
    "Exemple :\n",
    "\n",
    "```python\n",
    "a = 12\n",
    "\n",
    "if a % 2 == 0:\n",
    "    print(a, \" est un entier pair\")\n",
    "else:\n",
    "    print(a,\" est un entier impair\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Cas : Si...Alors...Sinon Si\n",
    "\n",
    "Dans cette structure on teste plusieurs conditions\n",
    "\n",
    "```\n",
    "    if condition1:\n",
    "        instruction1\n",
    "    elif condition2:\n",
    "        instruction2\n",
    "        instruction3\n",
    "    elif condition3:\n",
    "        instruction4\n",
    "    else:\n",
    "        instruction5\n",
    "```\n",
    "\n",
    "Exemple :\n",
    "\n",
    "Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n",
    "\n",
    "```python\n",
    "if feu == 'VERT':\n",
    "\tprint('Piéton, vous pouvez passer')\n",
    "elif voitures = 0 : # le feu est rouge\n",
    "    print('Piéton, vous pouvez passer mais attention')\n",
    "else: # le feu est rouge et il y a des voitures\n",
    "\tprint('Piéton, vous ne pouvez passer')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### À Faire\n",
    "\n",
    "Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :\n",
    "\n",
    "```txt\n",
    "  Demander la taille\n",
    "  Si la taille est supérieure à 1m80 alors\n",
    "\tla réponse est 'Maître, vous vous prenez pour Chewbacca'\n",
    "  Sinon si la taille est supérieure à 1m20 alors\n",
    "    la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'\n",
    "  Sinon si la taille est supérieure à 0.80m alors\n",
    "    la réponse est \"Maitre, ce n'est pas la taille qui compte\"\n",
    "  Sinon la réponse est 'Maitre, vous vous sous-estimez'\n",
    "```\n",
    "\n",
    "Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :\n",
    "\n",
    "```python\n",
    "taille = input('Combien mesures-tu ?')\n",
    "...\n",
    "print(reponse)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1\n",
    "\n",
    "L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer la corpulence d’un individu et donc les éventuels risques pour la santé.\n",
    "\n",
    "La formule de calcul a été vu lors de l'activité 1 sur les variables.\n",
    "\n",
    "L'OMS fournit l'interprétation suivante de l'état de santé en fonction de l'IMC :\n",
    "\n",
    "| Indice de masse corporelle (IMC) | Interprétation (d'après l'OMS) | \n",
    "| :--: | :--: |\n",
    "| moins de 18,5\t| Insuffisance pondérale (maigreur) |\n",
    "| 18,5 à 25 |\tCorpulence normale |\n",
    "| 25 à 30 | Surpoids |\n",
    "| 30 à 35 | Obésité modérée |\n",
    "| 35 à 40 | Obésité sévère |\n",
    "| plus de 40\t| Obésité morbide ou massive |\n",
    "\n",
    "Voici une liste de caractéristiques de célébrités anonymisées (i.e le nom a été changé par décence). \n",
    "\n",
    "| Célébrité | Taille (en cm) | Poids (en kg) | Interprétation |\n",
    "| :--: | :--: | :--: | :--: |\n",
    "| B | 169 | 56 | |\n",
    "| E | 157 | 48 | |\n",
    "| A | 175 | 90 | |\n",
    "| M | 205 | 200 | |\n",
    "| V | 163 | 42 | |\n",
    "| P | 170 | 75 | |\n",
    "| S | 191 | 113 | |\n",
    "\n",
    "1. Écrire un programme qui permet d'afficher l'état de santé en fonction de l'IMC, selon l'OMS, en utilisant des instructions conditionnelles.\n",
    "\n",
    "2. Compléter le tableau en fonction de vos résultats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2\n",
    "\n",
    "1. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le minimum des 3 entiers\n",
    "2. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le maximum des 3 entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3\n",
    "\n",
    "Écrire un programme pour vérifier si un nombre saisi par un utilisateur est divisible par 3 et 13 ou non,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4\n",
    "\n",
    "Écrire un programme pour vérifier si un caractère saisi par l'utilisateur est une voyelle ou une consonne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5\n",
    "\n",
    "Écrire un programme pour entrer le numéro du jour de la semaine (1-7) et affiche le nom du jour de la semaine correspondant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6\n",
    "\n",
    "Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris\n",
    "\n",
    "**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)\n",
    "\n",
    "( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)\n",
    "\n",
    "```python\n",
    "from p5 import *\n",
    "\n",
    "def setup():\n",
    "    createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
    "\n",
    "def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...\n",
    "    # les conditions pour la couleur du fond d'écran\n",
    "    if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)\n",
    "        background(255,120,0) # \n",
    "    elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)\n",
    "        background(0,255,120) #\n",
    "    else:\n",
    "        background(0,0,255) # fond bleu\n",
    "run()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 7\n",
    "\n",
    "Reprendre le code précédent(copier-coller) et en utilisant les instructions **mouseX** et **mouseY** (qui renvoie abscisse et ordonnée de la souris), faites en sorte qu'il y ait 4 couleurs différentes qui s'affichent suivant la position de la souris dans les quadrants:\n",
    "\n",
    "- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu\n",
    "- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert\n",
    "- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge\n",
    "- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 8\n",
    "\n",
    "Dans le code suivant on affiche dans la fenêtre 4 cercles et la couleur de fond change si la souris survole l'un des cercles.\n",
    "\n",
    "- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.\n",
    "- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).\n",
    "- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.\n",
    "\n",
    "Compléter le code de façon que le fond change de couleur au survol des 4 cercles.\n",
    "\n",
    "```python\n",
    "from p5 import *\n",
    "\n",
    "def setup():\n",
    "    createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
    "\n",
    "def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...\n",
    "    if dist(mouseX,mouseY,50,50) < 20:\n",
    "        background(255,255,0)\n",
    "    # à modifier ici\n",
    "    else:\n",
    "        background(51,51,51)\n",
    "    # ne pas modifier...\n",
    "    fill(0,0,0)\n",
    "    circle(50,50,40)\n",
    "    circle(150,150,40)\n",
    "    circle(150,50,40)\n",
    "    circle(50,150,40)\n",
    "    \n",
    "run()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 9\n",
    "\n",
    "Le code ci-dessous montre \"une balle\" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.\n",
    "\n",
    "Compléter le code de telle sorte que la balle se déplace aussi dans la verticale en rebondissant sur les bords inférieur et supérieur de la fenêtre.\n",
    "\n",
    "```python\n",
    "from p5 import *\n",
    "\n",
    "def setup():\n",
    "    global bx,by,vx,vy,r\n",
    "    r = 20\n",
    "    bx = 50\n",
    "    by = 50\n",
    "    vx = 4\n",
    "    vy = 5\n",
    "    createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels\n",
    "\n",
    "def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...\n",
    "    global bx,by,vx,vy,r\n",
    "    background(0,0,0)# fond noir\n",
    "    # mouvement du cercle sur l'axe horizontal\n",
    "    bx = bx + vx\n",
    "    # rebond sur les bords gauche et droit\n",
    "    if bx < r or bx > 400 - r:\n",
    "        vx = -vx\n",
    "    # dessin du cercle\n",
    "    fill(255,0,0)\n",
    "    circle(bx,by,2*r)    \n",
    "    \n",
    "run()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 10\n",
    "\n",
    "Reprendre le code précédent et faire en sorte que la \"balle\" change de couleur à chaque rebond\n",
    "\n",
    "Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
