3.InstructionsConditionnelles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=right> <font color='darkblue'>Une petite introduction à Python [3/5]</font></div>\n",
    "\n",
    "----\n",
    "\n",
    "# <font color=darkred> &#10070; Les instructions conditionnelles </font>\n",
    "## <font color=darkblue> &diams; Exemple introductif</font>\n",
    "\n",
    "\n",
    "Supposons que nous voulions créer un programme qui demande à l'utilisateur de répondre à des questions à choix multiples (QCM). Dans un souci de simplicité, nous supposerons que toutes les questions ont le même format : quatre réponses sont proposées et une seule est juste. \n",
    "\n",
    "Vous avez appris dans les notebook précédents à utiliser les instructions `print` et `input` permettant d'afficher une questions puis d'attendre la réponse de l'utilisateur aussi le début de programme dans la cellule suivante ne devrait pas vous poser de problèmes. Si tel était le cas, je vous invite à revenir sur le [notebook n°1](Intro1.ipynb) qui traite du `print` et des variables et/ou sur le [notebook 2](Intro2.ipynb) qui concernait l'instruction `input` et le type de variables.\n",
    "\n",
    "**Lisez** attentivement le code suivant, puis **exécutez** le :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Affiche une question et attend la réponse de l'utilisateur\n",
    "print(\"En python, une variable du type int contient : \")\n",
    "print(\"1.Une chaine de caractères    2.Un nombre entier    3.Un nombre à virgule    4.Une page web\")\n",
    "reponse = input(\"Tapez le numéro de votre réponse : \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exécuter** l'instruction conditionnelle `if` suivante qui va maintenant permettre de traiter la réponse de l'utilisateur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if reponse==\"2\":\n",
    "    print(\"Bravo, c'est la bonne réponse\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant d'analyser la syntaxe de cette instruction, un peu de vocabulaire : vous remarquez que l'instruction `print` ci-dessus est décalée vers la droite, on dit qu'elle est **indentée**. L'**indentation** (c'est à dire ce décalage vers la droite) s'obtient en mettant 4 espaces. Cela semble fastidieux mais bien souvent, cette indentation sera mise de façon automatique lorsque vous ferez le passage à la ligne après le caractère `:`.\n",
    "\n",
    "Du point de vue de la *syntaxe* maintenant :\n",
    "* On commence par écrire l'instruction `if` (si en anglais) elle est suivie d'un espace, d'une **condition** et du symbole `:`\n",
    "* Les instructions **indentées** qui suivent sont exécutées lorsque la condition est vraie, d'où le terme **instruction conditionnelle**\n",
    "* Pour tester une égalité on utilise le double égal : `==`<br>\n",
    "Comme pour les instructions `print` et `input` vues plus tôt, il faut vous familiariser avec cette syntaxe. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "1. <font color=\"green\"> Le code ci-dessus fonctionne-t-il si on teste la condition `reponse==2` ? Pourquoi ?</font>\n",
    "2. <font color=\"green\"> On dispose d'une variable `jour` et on doit écrire \"bon week-end !\" si `jour` est égal à samedi. Les 3 codes ci-dessous contiennent une erreur, **exécuter** les pour le constater. Puis, **corriger** ces erreurs. N'oubliez pas que les messages d'erreur fournis par Python, même s'ils sont en anglais, sont une aide précieuse !</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jour = \"samedi\" #changer le contenu de jour pour tester le code avec d'autres valeurs\n",
    "if jour=\"samedi\":\n",
    "    print(\"bon week-end !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jour = \"samedi\" #changer le contenu de jour pour tester le code avec d'autres valeurs\n",
    "if jour==\"samedi\"\n",
    "    print(\"bon week-end !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jour = \"samedi\" #changer le contenu de jour pour tester le code avec d'autres valeurs\n",
    "if jour==\"samedi\":\n",
    "print(\"bon week-end !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. <font color=\"green\"> Sur le principe du QCM de départ, écrire une question (faites prevue d'imagination), tester la réponse de l'utilisateur et écrire un message s'il donne la bonne réponse </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre code dans cette cellule\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans notre exemple de QCM, l'utilisateur reçoit un message de félicitations s'il trouve la bonne réponse, mais il ne se passe rien dans les **autres** cas, **autre** peut se traduire en anglais par **else**, et nous pouvons donc préciser à Python comme réagir lorsque la condition du `if` n'est pas validée. Reprenons notre exemple du début sur le QCM avec une nouvelle question qui cette fois traite les autres cas.\n",
    "\n",
    "**Exécuter** le programme suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Affiche une question et attend la réponse de l'utilisateur\n",
    "print(\"Le debut d'une instruction conditionnelle testant si la variable meteo contient 'soleil' s'écrit :\")\n",
    "print(\"1.if meteo=soleil:    2.if meteo='soleil':    3.if meteo=='soleil':    4.if meteo==soleil:\")\n",
    "reponse = input(\"Tapez le numéro de votre réponse : \")\n",
    "if reponse==\"3\":\n",
    "    print(\"Bravo, c'est la bonne réponse.\")\n",
    "else:\n",
    "    print(\"Désolé, vous avez commis une erreur.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poursuivons notre analyse de la syntaxe de cette nouvelle instruction\n",
    "\n",
    "* On *peut* compléter l'instruction `if` par un `else` \n",
    "* Le `else` est suivi du caractère `:`\n",
    "* Le(s) instruction(s) indentée(s) qui suivent le `else:` sont exécutés lorsque la condition du `if` n'est **pas** vérifiée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>&#9889; A retenir : </b><ul>\n",
    "<li> L'instruction if teste une <b>condition</b>.\n",
    "<li> Si cette condition est vraie, les instructions indentées qui suivent  le if sont exécutées.\n",
    "<li> Dans le cas contraire, les instructions indentées qui suivent le else (lorsqu'il est présent) sont éxécutées.\n",
    "    <li> On fera bien attention à la syntaxe du langage, et notamment à l'usage du caractère <b>:</b> qui précède l'indentation.\n",
    "     <li> Le symbole `==` est un test d'égalité (rappelons que `=` est réservé à l'affectation)\n",
    "</ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "4. <font color=\"green\"> **Corriger** le code ci-dessous qui ne fonctionne pas.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable1 = \"150\"\n",
    "variable2 = 150\n",
    "if variable1=variable2\n",
    "print(\"Les deux variables sont égales\")\n",
    "else\n",
    "print(\"Les deux variables ne sont pas égales\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. <font color=\"green\">Expliquer pourquoi ces deux variables ne sont pas égales. Changer le contenu de `variable1` pour vérifier qu'un flottant et un entier peuvent être égaux.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. <font color=\"green\"> **Ecrire** un programme python qui demande à l'utilisateur deux nombres `a` et `b`, lorsque `b` vaut 0, le programme affiche que la division de `a` par `b` n'est pas possible, sinon il affiche le résultat de `a` divisé par `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme division avec vérification du cas où le diviseur vaut 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. <font color=\"green\">**Ecrire** un QCM d'au moins 3 questions bâties sur le modèle donnée en introduction de ce notebook. Introduire une variable `score` qui comptera les points de l'utilisateur (1 point par bonne réponse). A la fin du QCM, afficher le score obtenu.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme QCM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; D'autres conditions </font>\n",
    "\n",
    "Nous avons jusqu'à présent rencontré uniquement le test d'égalité avec `a==b`, mais Python permet aussi de tester :\n",
    "* si `a` et `b` sont différents avec `a!=b`\n",
    "* si `a` est supérieur à `b` avec `a>b`\n",
    "* si `a` est inférieur à `b` avec `a<b`\n",
    "* si `a` est supérieur ou égale à `b` avec `a>=b`\n",
    "* si `a` est inférieur ou égale à `b` avec `a<=b`\n",
    "\n",
    "Ces tests fonctionnent sur les variables de types numériques mais aussi sur les **chaines de caractères**, dans ce cas c'est l'ordre **alphabétique** qui est utilisé. Vérifier le en changeant le contenu des variables du code ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "courgette est avant  fourchette  dans l'ordre alphabétique\n"
     ]
    }
   ],
   "source": [
    "# Chaine de caractères et comparaison avec le symbole < :\n",
    "var1 = \"courgette\"\n",
    "var2 = \"fourchette\"\n",
    "if var1 < var2:\n",
    "    print(var1,\"est avant \",var2,\" dans l'ordre alphabétique\")\n",
    "else:\n",
    "    print(var2,\"est avant \",var1,\" dans l'ordre alphabétique\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; Combiner des conditions : `and` et `or` </font>\n",
    "\n",
    "On peut combiner plusieurs conditions avec `and` (pour \"et\") et `or` (pour \"ou\").\n",
    "\n",
    "Supposons qu'on veuille tester si une variable `note` est bien comprise entre 0 et 20. On peut le faire en testant la condition `note>=0 and note<=20`.\n",
    "\n",
    "De même pour tester qu'une variable `jour` contient `samedi` ou `dimanche`. On pourra le faire en testant la condition `jour=='samedi' or jour=='dimanche'`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "8. <font color=\"green\"> **Ecrire** un programme qui demande à l'utilisateur deux nombres **entiers** puis détermine et affiche le plus grand de ces deux nombres. </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trouver le plus grand de deux nombres entiers tapés au clavier\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. <font color=\"green\"> On rappelle qu'en mathématiques, la valeur absolue d'un nombre $x$  se note $|x|$ et est définie par : </font> <br>\n",
    "$|x| = x$ si $x \\geq0$ <br>\n",
    "$|x| = -x$ sinon. <br>\n",
    "<font color=\"green\"> <b>Ecrire</b> un programme python qui demande à l'utilisateur un nombre puis affiche sa valeur absolue </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcule la valeur absolue d'un nombre x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. <font color=\"green\"> En chimie, une solution est dite acide lorsque son \"potentiel hydrogène\", noté pH  est strictement inférieure à 7, neutre lorsque son pH est égale à 7 et basique lorsque son pH est strictement supérieur à 7.<br>\n",
    "    **Ecrire** un programme python qui demande à l'utilisateur le pH de la solution puis indique si cette solution est acide, neutre ou basique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indique le type d'une solution (acide,neutre, base) en fonction de son pH\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. <font color=\"green\">Reprendre et améliorer votre programme de QCM écrit plus haut. Cette fois votre QCM devra comporter au moins 5 questions, devra calculer le score de l'utilisateur et en fin d'exécution lui faire un petit commentaire sur son résultat, par exemple 'Excellent ! Vous avez obtenu la note maximum' ou 'C'est moyen !' etc</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme QCM\n"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}