PythonNiveau2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python niveau 2\n",
    "\n",
    "## L'objet booléen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La prise de décision de Python se fait à l'aide de l'objet booléen. Celui-ci n'a que deux valeurs possibles : Vrai et Faux (True et False).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 == 1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# x est une étiquette sur l'objet booléen 1!=2\n",
    "x = (1!=2)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lorsque l'on teste une expression ou une condition, celle-ci ne peut prendre que l'une de ces deux valeurs. Remarquez les majuscules sur la première lettre.\n",
    "\n",
    "Tous les tests ou conditions mathématiques sont possibles, même l'appartenance à un ensemble que l'on verra plus loin.\n",
    "\n",
    "Nous avons donc :\n",
    "\n",
    "- `<` strictement plus petit\n",
    "- `<=` plus petit ou égal\n",
    "- `>` strictement plus grand\n",
    "- `>=` plus grand ou égal\n",
    "- `==` égal (à ne pas confondre avec le = du signe d'affectation)\n",
    "- `!=` différent\n",
    "- `< ... <` est compris strictement entre (et toutes les nuances)\n",
    "- `in` appartient (à un ensemble ou à une liste)\n",
    "- `is` est (pour vérifier que deux objets sont de même type)\n",
    "\n",
    "Dans l'exemple suivant, changer la valeur de `x` pour voir les différentes réponses de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 2.1\n",
    "1 <= x <3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'alternative et les boucles\n",
    "\n",
    "Les booléens sont utilisés dans les structures _**Si** test **Alors** faire ... **Sinon** faire ..._ et _**Tant que** test faire ... _\n",
    "\n",
    "En Python, on présente ce qu'il faut faire à l'aide d'un bloc d'instructions annoncé par le symbole **:** puis regroupés par une série de lignes commençant par le même nombre d'espace.\n",
    "\n",
    "Cette technique est aussi appelée indentation et permet une lecture plus fluide des instructions contenues dans un même bloc.\n",
    "\n",
    "N'oublions pas que Python parle anglais : **Si = if**, **Sinon = else** et **Tant que = while**.\n",
    "\n",
    "_faire_ est présenté par le **:** annonçant le bloc d'instructions à faire.\n",
    "\n",
    "### L'alternative\n",
    "\n",
    "Le **else** peut être omis s'il n'est pas nécessaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = -1\n",
    "if x < 0:\n",
    "    print('x est négatif')\n",
    "else:\n",
    "    print('x est positif ou nul')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'habitude est de mettre 4 espaces devant un bloc d'instructions pour pouvoir bien le voir. Cette valeur a été choisie pour pouvoir imbriquer plusieurs blocs les uns dans les autres et rester visible à l'écran.\n",
    "\n",
    "Les éditeurs Python l'utilisent automatiquement par défaut et les proposent automatiquement dès qu'une ligne finit par **:** (après appui sur entrée).\n",
    "\n",
    "Complétons l'exemple précédent. Dans le _sinon_, x a encore deux possibilités, distinguons-les.\n",
    "\n",
    "### Remarque\n",
    "\n",
    "le **else** est toujours indenté pour être au même niveau que son **if** (associé)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = -1\n",
    "if x < 0:\n",
    "    print('x est négatif')\n",
    "else:\n",
    "    if x == 0:\n",
    "        print('x est nul')\n",
    "    else:                       # le else est indenté pour être au niveau de son if\n",
    "        print('x est positif')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce cas : les si imbriqués, Python propose une structure prennant moins de place (moins de blocs imbriqués).\n",
    "\n",
    "Si le _Sinon_ ne contient qu'un _Si_, on l'abrège avec `elif`.\n",
    "\n",
    "Le _Sinon_ final est le _Sinon du Sinon_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "if x < 0:\n",
    "    print('x est négatif')\n",
    "elif x == 0:\n",
    "    print('x est nul')\n",
    "else:\n",
    "    print('x est positif')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les boucles\n",
    "\n",
    "La boucle _**Tant que** test faire ..._ permet de répéter un bloc d'instruction tant que le test (la condition) est vrai(e).\n",
    "\n",
    "On dit qu'un **Tant que** est une boucle comme dans un circuit, une fois arrivé à la fin du bloc d'instructions, on le recommence.\n",
    "\n",
    "Le test est appelé l'invariant du **Tant que**, il est toujours vrai dans le bloc d'instructions. Pour sortir de la boucle, il faut modifier les élements du test pour qu'il puisse devenir faux et quitter la boucle lors de son évaluation.\n",
    "\n",
    "L'exemple suivant compte de 0 à 9 et affiche les valeurs. C'est l'illustration d'une habitude tenace en informatique : Python commence à compter à partir de 0 et s'arrête à 9 quand il affiche 10 valeurs. Nous le reverrons bientôt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "compteur = 0\n",
    "# à l'intérieur de la boucle while on a toujours compteur < 10\n",
    "while compteur < 10:\n",
    "    print(compteur)\n",
    "    # le compteur doit être modifié pour pouvoir sortir de la boucle un jour\n",
    "    compteur = compteur + 1"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}