{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditions (IF)\n",
    "___\n",
    "\n",
    "Références de cette section :\n",
    "  - [Le cours Moodle sur les tests](https://moodle.insa-toulouse.fr/course/view.php?id=1090#section-3)\n",
    "  - [The Python Language Reference -- Compound statements](https://docs.python.org/3/reference/compound_stmts.html)\n",
    "  - [The Python Tutorial -- Control flow](https://docs.python.org/3/tutorial/controlflow.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un petit test préalable. Vérifions que nous sommes bien en Python 3 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print (sys.version)\n",
    "\n",
    "## Le raccourci pour évaluer une cellule de code : CTRL+ENTER\n",
    "## et le raccourci pour fermer la fenêtre d'évaluation : ESC + o"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expressions booléennes\n",
    "\n",
    "Une *expression booléenne* (ou *assertion* en maths) est une expression qui s'évalue en vrai (True) ou faux (False).\n",
    "\n",
    "Vérifiez par vous-même que, en Python, True existe mais pas true (de même False, mais pas false).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cette ligne efface toutes les définitions déjà faites jusqu'à présent. Vous la verrez souvent.\n",
    "%reset -f\n",
    "\n",
    "## Essayez True, puis true, puis False, puis false.\n",
    "trou\n",
    "\n",
    "## CTRL+ENTER ... ESC + o"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, devinez **avant d'exécuter** quelles sont les valeurs affichées par ce code :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "x = 42\n",
    "\n",
    "print(x > 10)\n",
    "print(x > 10 and x <= 40)\n",
    "print(not (x >= 20 or x >100))\n",
    "\n",
    "## % 2 signifie 'modulo 2'\n",
    "## Le test d'égalité s'écrit ==\n",
    "print( (x > 100 and x < 400) or (x % 2 == 0))\n",
    "\n",
    "## CTRL+ENTER ... ESC + o"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme dans beaucoup de langages (sauf Ada), les opérateurs ```and``` et ```or``` sont paresseux : l'argument ```B``` dans ```A and B``` n'est évalué que si ```A``` est vrai. De même, ```B``` n'est évalué que si ```A``` est faux dans ```A or B```.\n",
    "\n",
    "Nous définissons une fonction pour le mettre en évidence (et nous reviendrons plus tard sur les fonctions).\n",
    "\n",
    "Devinez combien de fois est affiché *stupido* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "## La fonction stupido est l'identité : elle renvoie son argument x.\n",
    "def stupido(x):\n",
    "    print(\"Stupido ! \")\n",
    "    return x\n",
    "\n",
    "y = 100\n",
    "(stupido(y) < 20 and stupido(y) > 0) or (stupido(y) == 100 or stupido(y) == 105)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le IF : syntaxe\n",
    "\n",
    "Futés comme vous êtes, deux exemples suffiront à assimiler la syntaxe du IF :\n",
    "\n",
    "Exemple 1 :\n",
    "```python\n",
    "if x >= 20:\n",
    "    print(\"x is greater than or equal to 20.\")\n",
    "```\n",
    "\n",
    "Exemple 2 :\n",
    "```python\n",
    "if x > 20:\n",
    "    print(\"x is greater than 20.\")\n",
    "elif x == 10:\n",
    "    print(\"x is 10.\")\n",
    "    print(\"not 20, but 10.\")\n",
    "else:\n",
    "    print(\"x is smaller or equal to 20 but is not 10.\")\n",
    "```\n",
    "\n",
    "Les mots-clés du if sont donc : **if**, **elif** (optionnel), **else** (optionnel). \n",
    "\n",
    "Quelques questions :\n",
    "  - Quel est le symbole que M. Le Botlan oublie à chaque fois qu'il écrit un IF ?\n",
    "  - Le ```elif``` est équivalent à ```else: if```. Quel est l'intérêt d'avoir un mot clé spécial ? (C'est plus court à taper, mais pas seulement).\n",
    "  - Devinette : je joue un rôle syntaxique essentiel en Python alors que dans pratiquement tous les autres langages, je ne suis qu'un détail esthétique. Qui suis-je ?\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le piège du =\n",
    "\n",
    "En C et en Python, le test d'égalité s'écrit ```==```.\n",
    "\n",
    "En C, qui est un langage vil, un piège bien connu est d'utiliser le ```=``` à la place de ```==``` dans un if. C'est un coup à chercher le bug pendant une semaine sans le trouver.\n",
    "\n",
    "Vérifiez si l'interpréteur Python est aussi fourbe que le compilateur C :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "x = 20\n",
    "if (x=99):\n",
    "    print(\"Piège.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le IF : sémantique\n",
    "\n",
    "La sémantique (le comportement) d'un IF dépend de la valeur placée en condition, ici ```something``` :\n",
    "\n",
    "```python\n",
    "if something:\n",
    "    bloc_then\n",
    "else:\n",
    "    bloc_else\n",
    "```\n",
    "\n",
    "  - Si ```something``` s'évalue en un **booléen**, le IF se comporte comme vous le pensez.\n",
    "  \n",
    "  - Si ```something``` est autre chose qu'un booléen, il se comporte comme False s'il est assimilé à un objet vide, et comme True sinon.\n",
    "  \n",
    "  Les valeurs Python assimilées à l'ensemble vide sont l'entier 0, le flottant 0.0, la liste vide [], le dictionnaire vide {}, le tuple vide (), ou encore la valeur renvoyée par une fonction qui ne renvoie (apparemment) rien, comme print.\n",
    "  \n",
    "  Vérifiez-le vous mêmes en plaçant différentes valeurs dans ```chose```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "## Essayer avec différentes valeurs : liste vide, liste non vide, tuple vide, une paire, un entier nul ou non nul, etc.\n",
    "chose = []\n",
    "\n",
    "if chose: print (\"Objet non vide\")\n",
    "else: print (\"Objet vide\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les curieux, essayez de comprendre ce qui se passe lorsque l'on met juste ```print``` dans ```chose```, et lorsque l'on met ```print(\"Bla\")```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Petite pause\n",
    "\n",
    "Allez chercher sur internet à quoi ressemble un if (l'arbre).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice\n",
    "\n",
    "Examinez le code ci-après. Il contient une fonction ```lescas```, que vous devrez compléter, et un test qui affiche la valeur de la fonction sur l'intervalle $[0,24]$. Vous n'avez pas à toucher à la boucle de test.\n",
    "\n",
    "Pour l'instant, la fonction lescas est l'identité (testez).\n",
    "\n",
    "Vous devez la modifier pour qu'elle respecte la spécification suivante :\n",
    "\n",
    "  - On considère que la fonction $lescas$ est définie sur l'ensemble des entiers.\n",
    "  - On note $P$ l'ensemble des nombres pairs et $I$ l'ensemble des nombres impairs.\n",
    "  - On note $A$ l'intervalle $[2 ; 7]$, $B$ l'intervalle $[8 ; 11]$, et $C$ l'intervalle $[12 ; 20]$.\n",
    "  - $\\forall x \\in P \\cap A, lescas(x) = -1$\n",
    "  - $\\forall x \\in I \\cap A, lescas(x) = 1$\n",
    "  - $\\forall x \\in B, lescas(x) = 2$\n",
    "  - $\\forall x \\in C, lescas(x) = -2$\n",
    "  - $\\forall x \\notin A \\cup B \\cup C, lescas(x) = 5$\n",
    "  - Chaque condition, comme (x < 8) ne doit apparaître qu'une seule fois dans tout votre code. \n",
    "  - Vous ne devez pas définir de variable, ni d'autre fonction. L'objectif est d'écrire des IF imbriqués.\n",
    "  \n",
    "  Ingrédients : 3 IF, 2 ELSE, 1 ELIF, 5 return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lescas(x):\n",
    "    if True:\n",
    "        return x\n",
    "    else:\n",
    "        return x\n",
    "    \n",
    "## Test de la fonction lescas\n",
    "\n",
    "for n in range(25):\n",
    "    print(\"lescas(\", n, \") = \", lescas(n))\n",
    "    \n",
    "\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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}