isn/bases.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.Cell.options_default.cm_config.lineNumbers = true;"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "IPython.Cell.options_default.cm_config.lineNumbers = true;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "/* Pour le titre comme cela il n'y a pas de numérotation au */\n",
       "#titre{\n",
       "font-size: 24pt; \n",
       "color:#ff0000;\n",
       "text-decoration: underline;\n",
       "text-align: center;\n",
       "font-weight: bold;\n",
       "}\n",
       "\n",
       "div.text_cell_render { font-size: 12pt;   line-height: 145%; }\n",
       "div.text_cell_render h1{font-size: 24pt; color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h2{font-size: 18pt;color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h3{font-size: 14pt;color:#0000ff;  text-decoration: underline;}\n",
       "div.text_cell_render h4{font-size: 12pt;color:#0000ff;  text-decoration: underline; }\n",
       "div.text_cell_render h5 {font-weight: 300;}\n",
       "\n",
       "\n",
       "div.cell.code_cell { /* area that contains code + output */\n",
       "    background: #ffffff;\n",
       "    border: none;\n",
       "    border-radius: 10px;\n",
       "    padding-top: 1ex;\n",
       "}\n",
       "\n",
       "div.input_area { /* box around box with code */\n",
       "    border: none;\n",
       "    background: #f5f5f5;\n",
       "    border: 1px solid #ccc;\n",
       "    border-radius: 10px;\n",
       "    padding-top: 0.5ex;\n",
       "    padding-bottom: 0.5ex;\n",
       "    padding-left: 0.5em;\n",
       "}\n",
       "\n",
       "div.input { /* box with code */\n",
       "}\n",
       "\n",
       "div.CodeMirror { /* code font */\n",
       "    font-family: \"Inconsolata-dz\", monospace;\n",
       "    font-size: 10pt;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "/*div.text_cell_render  code { font-size: medium; border: 3px #ababab solid; background-color: #f5f5f5;}*/\n",
       "/*.rendered_html code { border: 3px #ababab solid; background-color:  #f5f5f5;}*/\n",
       ".rendered_html blockquote { margin: 1em 2em; background: red; }\n",
       ".rendered_html ol { list-style:decimal; margin: 1em 2em; }\n",
       "\n",
       "\n",
       "/* classe pour inverse video */\n",
       ".reverse{\n",
       "    background-color: black;\n",
       "    color: white;\n",
       "}\n",
       "/*  strick   <s>texte/<s>*/\n",
       ".barre{\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Charge ma feuille de style pour nbviewer\n",
    "from IPython.core.display import HTML\n",
    "from  urllib.request import urlopen\n",
    "# import urllib.request, urllib.parse, urllib.error\n",
    "\n",
    "url='https://github.com/debimax/cours-debimax/raw/master/static/custom.css'\n",
    "with urlopen(url) as response:\n",
    "    styles = response.read().decode(\"utf8\")\n",
    "styles=\"<style>\\n{}\\n</style>\".format(styles)\n",
    "HTML(styles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"titre\">Les bases de python3</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hello World\n",
    "On ne va pas y échapper, quand on apprend un langage, le premier programme étudié est le programme qui affiche \"Hello World!\".\n",
    "On utilisera ipython qui est shell python amélioré."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est relativement simple.\n",
    "\n",
    "Remarquez au passage l'absence de point-virgule en fin de ligne, contrairement au C, à Java et à bon nombre de langages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La syntaxe générale\n",
    "\n",
    "## indentation\n",
    "\n",
    "Python oblige donc le développeur à structurer son code a l'aide des ***indentations*** : ce sont elles qui détermineront les blocs (séquences d'instructions liées) et non les accolades comme dans la majorité des langages.\n",
    "\n",
    "## Commentaires \n",
    "Le caractère **\\#** permet d'indiquer que tous les caractères suivants sur la même ligne ne doivent pas être interprétés. il s'agit de commentaires\n",
    "\n",
    "##  Variables\n",
    "\n",
    "Python utilise le symbole ***=*** pour affecter une valeur à une variable.  \n",
    "par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a==12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention: a=12 place la valeur 12 dans la variable a mais a==12 vérifie si la variable a est égale à 12, c'est donc un boléen. (***True*** ici car a est bien égal à 12).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérateurs d'incrémentation ou de décrémentation ++ ou - n'existent pas en Python.  \n",
    "Par contre, vous avez la possibilité d'effectuer des affectations de variables multiples avec une même\n",
    "valeur :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=b=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et vous pouvez également effectuer des affectations multiples de variables ayant des valeurs différentes en séparant les noms de variables et les valeurs par des virgules :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " a,b = 2,3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce mécanisme peut paraître anodin, mais il permet de réaliser très simplement une permutation de valeurs sans avoir recours a une variable intermédiaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2\n",
    "b=3\n",
    "a,b = b,a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les opérateurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe de nombreux opérateurs comme l'addition ***+*** la soustraction ***-*** la multiplication ***\\****  et la division ***\\\\*** \n",
    "\n",
    "En voici d'autre que l'on utilise souvent.\n",
    "\n",
    "7***//***2 est le ***quotient*** de la division euclidienne de 7 par 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7***%***2 est le ***reste*** de la division euclidienne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7%2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7\\*\\*2 pour 7 à la ***puissance*** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***sqrt(2)*** pour la ***racine carré*** de 2.  \n",
    "Attention il faut auparavant importer la librairie ***math***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou alors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les différents types de données\n",
    "\n",
    "Pour pouvoir travailler sur les types, nous aurons besoin de faire appel à une fonction : la fonction **_type()_**.  \n",
    "Le rôle de cette fonction est d'afficher le type de l'élément qui lui est passé en paramètre. \n",
    "\n",
    "## Les données numériques\n",
    "Parmi les données manipulables, on va bien entendu pouvoir utiliser des nombres. Ceux-ci sont classés en quatre types numériques :     \n",
    "### Entier  \n",
    "Python permet de représenter les entiers sur 32 bits (de -2147483648=-$2^{31}$ à 2147483647=$2^{31}-1$).   \n",
    "La représentation des entiers dépend de la version python 2 ou 3, du système utilisé (32 ou 64 bit). On utilisera le module sys pour connaitre la valeur max."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.maxsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(sys.maxsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(sys.maxsize+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Des préfixes particuliers permettent d'utiliser la notation octale (en base huit) ou hexadécimale (en base seize). \n",
    "- Pour la notation octale, il faudra préfixer les entiers par **_0o_** (le chiffre zéro suivi de la lettre << o >> en minuscule).   \n",
    "  Par exemple, 12 en notation octale vaut 8+2=10 :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0o12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Pour la notation hexadécimale, le préfixe sera 0x (le chiffre zéro suivi de la lettre << x >> en minuscule).  \n",
    "Ainsi, 12 en notation hexadécimale vaut 16+2=18 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0x12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut convertir aussi un nombre ou un texte en entier avec la fonction ***int()***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(int(\"16\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flottant\n",
    "pour les nombres flottants. Le symbole utilisé pour déterminer la partie décimale est le\n",
    "point. On peut également utiliser la lettre E ou e pour signaler un exposant en base 10 (101, 102,\n",
    "etc.).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "type(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2e3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2e1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut convertir aussi un nombre ou un texte en flottant avec la fonction ***float()***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(float(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float('3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complexe\n",
    "\n",
    "Pour les nombres complexes qui sont représentés par leur partie réelle et leur partie imaginaire.  \n",
    "En Python, la partie imaginaire sera logiquement suivie de la lettre J ou j.  \n",
    "En informatique, on utilise souvent la variable i  comme variable de boucle (dont nous parlerons par la suite), Pour éviter toute confusion, la partie imaginaire des complexes se note donc j. Voici comment écrire le complexe 2 + 3i :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+3j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2+3j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problème avec les flottants \n",
    "L'interpréteur interactif peut être utilisé comme une calculette. Pour l'instant nous ne parlerons que des opérations élémentaires **+,-,* ** et **/** auxquelles nous ajouterons le quotient de la division euclidienne noté **//** (ou **_div_** ) et le reste de la division euclidienne noté **%** (ou **_mod_** ). Voici quelques exemples de calculs : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7.0/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7%3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les résultats paraissent ici logiques: 7/3 et 7.0/3.0 donnent le même résultat sous la forme d'un flottant et 7//3 a pour résultat 2 qui est bien le quotient de la division euclidienne de 7 par 3.  \n",
    "Si vous utilisez les calculs en Python, l'usage de la division peut donc être source d'erreur et il faudra donc bien se souvenir de la version de Python employée. Mais il y a pire ... et ce n'est pas l'apanage de Python.\n",
    "\n",
    "Le phénomène que je m'apprête à souligner est vrai pour absolument tous les langages, mais il est bien souvent oublié. Quel est le résultat d'une opération simple telle que 0.7 + 0.1 ? \n",
    "\n",
    "Vous pensez que le résultat est 0.8 ? Testons donc en Python :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.7+0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dirait qu'il y a un problème ... En fait cela provient de la représentation des flottants en machine :  \n",
    "ils sont arrondis !\n",
    "En Python, la solution consistera a utiliser un module spécial, le module **_Decimal_**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import *\n",
    "Decimal('0.1')+Decimal('0.7')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Si vous manipulez des flottants pour des calculs précis, méfiez vous !  **"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les chaîne caractères\n",
    "Les chaînes de caractères sont encadrées par des apostrophes ou des guillemets. Le choix de l'un ou de l'autre n'a aucun impact au niveau des performances.  \n",
    "La concaténation (assemblage de plusieurs chaînes pour n'en produire qu'une seule) se fait à l'aide de l'opérateur ***+***."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=\"Hello \"\n",
    "b=\"World !\"\n",
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "l'opérateur ** \\* ** permet de répéter une chaîne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3*a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'accès à un caractère particulier de la chaîne se fait en indiquant sa position entre crochets (le premier caractère est à la position 0) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, on peut faire beaucoup de choses avec les chaînes de caractères ... nous verrons cela plus en détail dans l'article consacré aux chaînes et aux listes.  \n",
    "\n",
    "## Les boléens\n",
    "Les valeurs booléennes sont notées **_True_** et **_False_** (attention à la majuscule). \n",
    "\n",
    "Dans le cadre d'un test, les valeurs **_0_**, **_\"\"_** (la chaîne vide) et **_None_** sont considérées comme étant égales à **_False_**. Ces valeurs sont retournées comme résultats des tests réalisés à l'aide des opérateurs de comparaison :  \n",
    "**==** pour l'égalité, **!=** pour la différence, puis **<**, **>**, **<=** , et **>=**.  \n",
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2==3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2<=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour combiner les tests, on utilise les opérateurs booléens (ou connecteurs logiques): \n",
    "\n",
    "\n",
    "\n",
    "**_and_** (et), **_or_** (ou), ***xor*** et ***not*** (non).\n",
    "\n",
    "- et : <condition1> et <condition2> est vraie si les deux conditions sont vraies simultanément.\n",
    "- ou : <condition1> ou <condition2> est vraie si au moins une des deux conditions est vraie.\n",
    "- xor : xor est un ou exclusif (eXclusive OR). La condition <condition1> xor <condition2> est vraie si exactement une des deux conditions est vraie.\n",
    "- non : non(<condition1>) est le contraire de <condition1>.\n",
    "\n",
    "<div style=\"width: 200px; float:left\">\n",
    "<table>\n",
    "<tr><th>et</th><th>V</th><th>F</th></tr>\n",
    "<tr><td><b><i>V</i></b></td><td>V</td><td>F</td><tr>\n",
    "<tr><td><b><i>F</i></b></td><td>F</td><td>F</td><tr>\n",
    "</table>\n",
    "</div>\n",
    "<div style=\"width: 200px; float:left\">\n",
    "<table>\n",
    "<tr><th>ou</th><th>V</th><th>F</th></tr>\n",
    "<tr><td><b><i>V</i></b></td><td>V</td><td>V</td><tr>\n",
    "<tr><td><b><i>F</i></b></td><td>V</td><td>F</td><tr>\n",
    "</table>\n",
    "</div>\n",
    "<div style=\"width: 200px; float:left\">\n",
    "<table>\n",
    "<tr><th>xor</th><th>V</th><th>F</th></tr>\n",
    "<tr><td><b><i>V</i></b></td><td>F</td><td>V</td><tr>\n",
    "<tr><td><b><i>F</i></b></td><td>V</td><td>F</td><tr>\n",
    "</table>\n",
    "</div>\n",
    "<div style=\"width: 200px; float:left\">\n",
    "<table>\n",
    "<tr><th>not</th><th>V</th><th>F</th></tr>\n",
    "<tr><td></td><td>F</td><td>V</td><tr>\n",
    "</table>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici un comparatif entre l'algorithmique et python: \n",
    "\n",
    "<table>\n",
    "<tr><th>Algorithmique</th><th>python</th></tr>\n",
    "<tr><td>a=b</td><td>a==b</td><tr>\n",
    "<tr><td>a&ne;b</td><td>a!=b</td><tr>\n",
    "<tr><td>A et B</td><td>A and B<br /> A & B</td><tr>\n",
    "<tr><td>A ou B</td><td>A or B <br /> A &#124; B</td><tr>\n",
    "<tr><td>A xor B</td><td>A ^ B</td><tr>\n",
    "<tr><td>non A </td><td>not(A)</td><tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1>2 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2>1 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1>2 or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les listes, les tuples et les dictionnaires\n",
    "\n",
    "Nous allons maintenant voir trois types particuliers présentant de fortes similitudes : les listes, les tuples et les dictionnaires. Ces types étant un peu complexes, il ne s'agit ici que d'un premier aperçu, nous les étudierons plus en détail dans l'article leur étant consacré.  \n",
    "### Les listes \n",
    "Une liste est un ensemble d'éléments éventuellement de différents types. Une liste se définit à laide des crochets et une liste vide est symbolisée par [].  \n",
    "L'accès à un élément de la liste se fait en donnant son index, de la même manière qu'avec les chaînes de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maliste=[3.14, \"cours isn\", 1+1j, 5]\n",
    "maliste[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les tuples \n",
    "Les tuples sont des listes particulières, on ne peux pas les modifier, nous verrons l'intérêt plus tard. Ils sont définis par des parenthèses et leurs éléments sont accessibles de la même manière que pour les listes.  \n",
    "Notez que pour lever toute ambiguïté, un tuple ne contenant qu'un seul élément sera noté (élément,). Si vous omettez la virgule, Python pensera qu'il s'agit d'un parenthèsage superflu et vous n'aurez donc pas créé un tuple.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=(2,3)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type((2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type((2,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exemple des listes peut tout a fait être rapporté aux tuples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "montuple=(3.14, \"cours isn\", 1+1j, 5)\n",
    "montuple[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les dictionnaires \n",
    "\n",
    "Un dictionnaire est une liste où l'accès aux éléments se fait à l'aide d'une clé alphanumérique ou purement numérique. Il s'agit d'une association clé/valeur sous la forme **_clé:valeur_**.  \n",
    "Les dictionnaires sont définis a l'aide des **accolades**. Dans d'autres langages les dictionnaires sont aussi appelés tableaux associatifs ou tables de hachage. Voici un exemple d'utilisation d'un dictionnaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " t ={ 'nom' : 'Meilland' , 'prenom' : 'jean claude' }\n",
    " t['nom']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le type byte\n",
    "Le type ***byte*** est un type souvent utilisé avec python3.  C'est un tableau d'octets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unbyte=b'ceci est un byte'\n",
    "print(unbyte)\n",
    "type(unbyte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À quoi sert un byte?\n",
    "\n",
    "Généralement à tout échange de données. Par exemple:  \n",
    "- Executer un logiciel quelconque sur l'ordinateur,\n",
    "- Parser une page internet (analyse syntaxique qui permet d'obtenir le code de la page internet),\n",
    "- lire un fichier texte \n",
    "- etc..\n",
    "\n",
    "Voici un exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='Pablo Neruda'\n",
    "b=a.encode('utf8')\n",
    "print(a)\n",
    "print(b)\n",
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le ***b***  est là pour signifier que la type est byte\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=b.decode('utf8')\n",
    "print(b)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut passer du type byte à string en encodant en utf8 par exemple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## retenir\n",
    "\n",
    "Les différents types entiers, flottants, complexes, chaînes de caractères, boléens, listes,  tuples et dictionnaires.\n",
    "\n",
    "- ***entier***: 3  \n",
    "- ***flottant***: 2.3  \n",
    "- ***complexe***: 1+2j  \n",
    "- ***chaînes de caractères (string)***: 'ISN'  \n",
    "- ***Boléen***: True  \n",
    "- ***Listes***: [0,1,2,3]  \n",
    "- ***Tuples***: (0,1,2,3)  \n",
    "- ***Dictionnaires***: {'zero':0, 'un':1, 'deux':2,'trois':3}  \n",
    "- ***Byte***: b'toto'\n",
    "\n",
    "On aura toujours à l'esprit que 0.2+0.7=0.8999999999999999$\\neq0.9$\n",
    "\n",
    "- ***int()*** permet de convertir, un nombre ou une chaîne de caractère en un entier.  \n",
    "- ***float()*** permet de convertir, un nombre ou une chaîne de caractère en un flottant.\n",
    "\n",
    "- Quelques opérateur déjà vu et très utiles\n",
    "\n",
    "<html><table>\n",
    "    <tr><th>Opération</th><th>algorithme </th><th>python</th></tr>\n",
    "    <tr><td>addition</td><td>2+3</td><td>2+3</td>\n",
    "    <tr><td>Soustraction</td><td>12-5</td><td>12-5</td>\n",
    "    <tr><td>Multiplication </td><td> 3*6 </td><td>3*6 </td>\n",
    "    <tr><td>Division </td><td> 7/2 </td><td> 7/2</td>\n",
    "    <tr><td>Quotient de la division euclidienne </td><td> 7 div 2 ou div(7,2) </td><td> 7//2 </td>  \n",
    "    <tr><td>Reste de la division euclidienne </td><td>  7 mod 2 ou mod(7,2) </td><td>  7%2 </td>\n",
    "    <tr><td>puissance </td><td> $7^2$ </td><td>7\\*\\*2</td>\n",
    "    <tr><td>racine carrée </td><td> $\\sqrt{2}$ ou sqrt(2) </td><td> sqrt(2)</td> \n",
    "  </table>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les entrées et les sorties  E/S\n",
    "\n",
    "## Entrer des données\n",
    "Il est parfois nécessaire d'entrer des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"Entrer un texte a: \")\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=int(input(\"Entrer un entier b: \"))\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=float(input(\"Entrer un réel c: \"))\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention  *b=int(input(\"Entrer un entier b: \"))*   indique une erreur si on saisit par exemple 2.3  \n",
    "Pour arrondir 2.3 à 2 On utilisera ***float*** et ***int***."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d=int(float(input(\"Entrer un réel c: \")))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Afficher un texte ou la valeur d'une variable\n",
    "\n",
    "On utilise pour afficher un texte ou la valeur d'une variable la fonction ***print()***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('toto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='Meilland jean claude'\n",
    "b='Lebowski Jeff'\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a,b,sep='\\n')  # sep signifie séparateur  et \\n pour newline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut assi afficher du texte et des variables. Il existe plusieurs méthodes\n",
    "\n",
    "  ### méthode 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=12\n",
    "print(\"La valeur de la variable a est \",str(a),\".\",sep='') # par defaut sep est un espace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ii. Méthode 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"La valeur de la variable a est \" + str(a) + \".\") # autre forme avec des +"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Méthode 3  avec la méthode format()\n",
    "\n",
    "Avec python3  il est conseillé d'utiliser cette méthode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"La valeur de la variable a est {}.\".format(a)) # Cette méthode est à préférer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On remplace {} par le contenu de la variable a. Peu importe ici si a est un texte, un flottant Le résultat sera affiché.\n",
    "\n",
    "Voici des exemple un peu plus complexe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=4\n",
    "b=5\n",
    "print(\"Le produit de {} par {} est {}\".format(a,b,a*b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " print(\"{0}*{1}={2} et {0}/{1}={3}\".format(a,b,a*b,a/b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## À retenir\n",
    "\n",
    "- On utilise le caractre ***\\#*** pour écrire un commentaire\n",
    "- Python utilise le symbole ***=*** pour affecter une valeur à une variable.  \n",
    "Attention à ne pas confondre a=12 et a==12.\n",
    "- ***input(\"texte\")***  permet de saisir du texte pour un programme.  \n",
    "- Il faudra éventuellement convertir ce texte dans le type voulu avec ***int()*** ou ***float()***\n",
    "- On utilise de préférence la méthode ***format()*** pour afficher du texte et des variables.  \n",
    "<html><br /><code>print(\"Le produit de {} par {} est {}\".format(a,b,a*b))</code></html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les structures de boucle et de test\n",
    "\n",
    "## Les structures de test\n",
    "\n",
    "### Si ...  alors ...  sinon\n",
    "<html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">\n",
    "if condition:\n",
    "    # Traitement bloc 1\n",
    "else:\n",
    "    # Traitement bloc 2\n",
    "</code></div></html>\n",
    "\n",
    "  Pour les tests multiples, il faudra enchaîner les if en cascade grâce à l'instruction elif, contraction de else if :\n",
    "\n",
    "  <html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">\n",
    "if condition:\n",
    "           # Traitement bloc 1\n",
    "elif:\n",
    "    # Traitement bloc 2\n",
    "else:\n",
    "    # Traitement bloc 3\n",
    "</code></div></html>\n",
    "\n",
    "  Par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=3\n",
    "if a>1:\n",
    "    print('a>1')\n",
    "else:\n",
    "    print('a<=2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  try (pour gérer les erreurs)\n",
    "  Ce n'est pas exectement unestructure de test mais elle s'en rapproche.\n",
    " \n",
    "  <html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">try:\n",
    "    # commandes\n",
    "except:\n",
    "    # traitement des erreurs\n",
    "finaly:\n",
    "    # commandes à exécuter dans tous les cas</code></div></html>\n",
    "    \n",
    "    par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=1\n",
    "b=0\n",
    "try:\n",
    "    c=a/b\n",
    "    print(c)\n",
    "except (ZeroDivisionError): print('Vous ne pouvez pas diviser par 0')\n",
    "except: print('il y a une autre erreur')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme précédent en modifiant la 2° ligne par:  <html><code  style=\"background-color:#80BFFF\">b='a'</code><html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    a=int(input(\"saisir un entier\"))\n",
    "    print(\"Vous avez l'entier {}\".format(a))\n",
    "except:\n",
    "    print(\"Il fallait entrer un entier\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici une variante que j'utilise de temps en temps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "while 1:\n",
    "    try:\n",
    "        a=int(input(\"saisir un entier\"))\n",
    "    except:\n",
    "        pass\n",
    "    else:\n",
    "        break\n",
    "print(\"Vous avez l'entier {}\".format(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme demande de saisir un entier jusqu'au moment où l'on rentre un entier.   \n",
    "Avec ***try*** on est obligé d'utiliser ***except***, c'est pourquoi j'utlise ***pass***."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les structures de boucle\n",
    "\n",
    "Pour les boucles il existe deux structures. \n",
    "\n",
    "### La boucle for\n",
    "La boucle **_for_** prend ses valeurs dans une liste :\n",
    "\n",
    "**for *variable* in *liste_valeurs* **. À chaque itération la variable prendra pour valeur un élément de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in [ 'pomme' , 'poire' , 'kiwi' ]:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour créer une boucle équivalente aux boucles traditionnelles << pour i allant de m à n, faire ... >>, nous utiliserons la fonction ***range()***.  \n",
    "La syntaxe générale est ***for i in range(m,n,p):***  \n",
    "**i prend alors toutes les valeurs de m à n-1 par pas de p**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,6,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4,0,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le mot-clé **_continue_** permet de passer à l'itération suivante et le mot-clé **_break_** permet de sortir de la boucle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    if i==2:\n",
    "        continue\n",
    "    if i==6:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  La boucle while\n",
    "\n",
    "La seconde structure de boucle est le *<< tant que >>* : tant qu'une condition est vraie, on boucle.  \n",
    "Attention : dans ce type de boucle on utilise une variable de boucle dont la valeur doit changer pour pouvoir sortir de la boucle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "while i<4:\n",
    "    print(i)\n",
    "    i+=1 #équivalent à i=i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La boucle **_while_** accepte elle aussi les mots-clés **_continue_** et **_break_**.\n",
    "\n",
    "\n",
    "## À retenir.\n",
    "\n",
    "Il faut absolument savoir utiliser les test ***if*** et boucles ***for*** et ***while***\n",
    "\n",
    "Il n'y a que les exercices qui vous permettrons de vous familiariser avec ceci. \n",
    "\n",
    "# La structure d'un programme\n",
    "\n",
    "Avec L'ensemble des instructions que nous avons vu, vous pouvez écrire des programmes plus longs que les quelques lignes testées dans l'interpréteur interactif. Vous allez donc avoir besoin de stocker vos scripts dans des fichiers d'extension **.py**.  \n",
    "\n",
    "Pour exécuter ces fichiers de code vous aurez alors deux possibilités :\n",
    " - soit lancer simplement dans un terminal :  \n",
    "   python3 monFichier.py\n",
    " - soit ajouter à votre code source une ligne indiquant où se trouve l'interpréteur Python à utiliser :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/python3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette ligne doit être la première ligne de votre fichier. Ensuite vous n'avez plus qu'a rendre votre fichier exécutable (chmod u+x monFichier.py ) et vous pourrez lancer votre script par :  ./monFichier.py\n",
    "\n",
    "# Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1**: Demander à l'utilisateur de saisir les longueurs et largeurs d'un rectangle, afficher sa surface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Exercice 2**: Saisir une note, afficher \"Ajourné\" si la note est inférieure à 8, \"Oral vous avez eu << la note >>\" entre 8 et 10, \"Admis\" au dessus de 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3**: Saisir trois entiers a,b et c. Puis déterminer le nombre de racines ainsi que les racines du polynôme $ax^2+bx+c$\n",
    "\n",
    "Aide! Pour utiliser la racine carré  (square root en anglais) il faut importer la librairie ***math***.  \n",
    "Par exemple pour calculer $\\sqrt(2)$\n",
    "<html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">import math\n",
    "math.sqrt(2)\n",
    "</code></div></html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 4**:  Une compagnie d'assurance effectue des remboursements en laissant une somme, appelée franchise, à la charge du client. La franchise représente 10% du montant des dommages sans toutefois\n",
    "pouvoir être inférieure à 15 euros ou supérieure à 500 euros.  \n",
    "\n",
    "Écrire un algorithme demandant à l'utilisateur de saisir le montant des dommages et lui affichant le montant payé par l'assurance ainsi que le montant de la franchise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 5**:  Qu'affiche le programme suivant:\n",
    "\n",
    "<html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">a=1  \n",
    "b=2  \n",
    "if a>=b:\n",
    "    a=b\n",
    "else:\n",
    "    b=a\n",
    "print(\"a={} et b={}\".format(a,b))\n",
    "</code></div></html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 6**: Saisir une valeur et afficher sa valeur absolue (sans utiliser math.fabs bien sur).  \n",
    "Méthode 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Méthode2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 7**: Saisir trois valeurs puis afficher la plus petite de ces valeurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 8**:  Saisir trois valeurs puis afficher  le nombre de valeurs égales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 9**:  La factorielle de l'entier $n$ est le nombre noté $n!$ avec $n! = n \\times (n - 1) \\times \\dots  \\times 2 \\times 1$.  \n",
    "Écrire un algorithme calculant la factorielle d'un nombre saisi par l'utilisateur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 10**: Écrire un algorithme qui  créer un nombre aléatoire entre 1 et 1000.  \n",
    "il faudra ensuite trouver ce nombre en saisissant des nombres tant que que le nombre mystère n'a pas été trouvé, et afficher à chaque fois le texte \"c'est plus\" (le nombre proposé est trop petit) ou \"c'est moins\" (le nombre proposé est trop grand) selon les cas.  \n",
    "À la fin il faudra afficher le texte \"Nombre d'essais nécessaires : \" puis, le nombre d'essais qui ont été nécessaires.\n",
    "\n",
    "\n",
    "On utilisera pour générer le nombre aléatoire entre 1 et 1000 le code ci-dessous\n",
    "\n",
    "  <html>\n",
    "<div  style=\"background-color:#80BFFF\">\n",
    "<code style=\"background-color:#80BFFF\">import random\n",
    "mystere=random.randint(1,1000)\n",
    "</code></div></html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 11**:  Écrire un algorithme qui affiche les tables de multiplications comme ci-dessous.  \n",
    "\n",
    "<html>\n",
    "<table><tr><td></td><td><b>1</b></td><td><b>2</b></td><td><b>3</b></td><td><b>4</b></td><td><b>5</b></td><td><b>6</b></td><td><b>7</b></td><td><b>8</b></td><td><b>9</b></td></tr>\n",
    "    <tr><td><b>1</b></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td></tr>\n",
    "    <tr><td><b>2</b></td><td>2</td><td>4</td><td>6</td><td>8</td><td>10</td><td>12</td><td>14</td><td>16</td><td>18</td></tr>\n",
    "    <tr><td><b>3</b></td><td>3</td><td>6</td><td>9</td><td>12</td><td>15</td><td>18</td><td>21</td><td>24</td><td>27</td></tr>\n",
    "    <tr><td><b>4</b></td><td>4</td><td>8</td><td>12</td><td>16</td><td>20</td><td>24</td><td>28</td><td>32</td><td>36</td></tr>\n",
    "    <tr><td><b>5</b></td><td>5</td><td>10</td><td>15</td><td>20</td><td>25</td><td>30</td><td>35</td><td>40</td><td>45</td></tr>\n",
    "    <tr><td><b>6</b></td><td>6</td><td>12</td><td>18</td><td>24</td><td>30</td><td>36</td><td>42</td><td>48</td><td>54</td></tr>\n",
    "    <tr><td><b>7</b></td><td>7</td><td>14</td><td>21</td><td>28</td><td>35</td><td>42</td><td>49</td><td>56</td><td>63</td></tr>\n",
    "    <tr><td><b>8</b></td><td>8</td><td>16</td><td>24</td><td>32</td><td>40</td><td>48</td><td>56</td><td>64</td><td>72</td></tr>\n",
    "    <tr><td><b>9</b></td><td>9</td><td>18</td><td>27</td><td>36</td><td>45</td><td>54</td><td>63</td><td>72</td><td>81</td></tr>\n",
    "    </table>\n",
    "</html>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 12**:  Écrire un programme demandant à l'utilisateur de saisir une valeur numérique positive n et affichant toutes les valeurs n, n - 1, . . . , 2, 1, 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 13**: Écrire un algorithme demandant la saisie d'un nombre n et calculant $n^n$ .  \n",
    "Par exemple, si l'utilisateur saisit 3, l'algorithme lui affiche  \n",
    "- a) $3^3 = 27$.\n",
    "- b) $3^3 = 3 \\times 3 \\times 3 = 27$.  (plus difficile) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 14**:  Écrivez un algorithme saisissant un nombre $n$ et calculant la somme suivante :\n",
    "\n",
    "$$S=1+2+3+...+n$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 15**:  Écrivez un algorithme saisissant un nombre n et calculant la somme suivante :\n",
    "\n",
    "$$S=\\dfrac{1}{1}-\\dfrac{1}{2}+\\dfrac{1}{3}-\\dfrac{1}{4}+  \\dots + \\dfrac{(-1)^{n+1}}{n}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 16**: Soit $(u_n)$ la suite définie par $u_n=0.8 \\times n +1$  \n",
    "Afficher les 100 premiers termes termes de la suites $(u_n)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 17**:  Soit $(u_n)$ la suite définie par $\\left\\lbrace\\begin{array}{l} u_{n+1}=0.8\\times u_n+1 \\\\ u_0=2\\\\ \\end{array}\\right.$  \n",
    "Afficher les 100 premiers termes termes de la suites $(u_n)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 18**:  Soit $(u_n)$ la suite définie par  $\\left\\lbrace\\begin{array}{l} u_{n+1}=2 \\times u_n\\\\ u_0=0.1\\\\ \\end{array}\\right.$  \n",
    "\n",
    "Déterminer $n$  tel que $u_n \\geq 384\\ 400\\ 000\\ 000$   (distance terre lune en mm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 19**:   On veut empiler des boîtes cubiques comme indiqué ci-dessous.\n",
    "\n",
    "<!-- <center><img src=\"./images/base_de_pb_ouverts_130.png\"></center> -->\n",
    "  \n",
    "<center><img src=\"http://megamaths.hd.free.fr/~pi/statics/base_de_pb_ouverts_130.png\"></center>\n",
    "On dispose de 500 boites, combien de rangés pourra t on faire?\n",
    " \n",
    "Écrire un programme pour répondre à cette question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Pour aller plus loin \n",
    "\n",
    "##  Les fonctions\n",
    "\n",
    "Les fonctions se définissent de la façon suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nomfonction(variable):\n",
    "    .......\n",
    "    return valeurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut retourner plusieurs valeurs avec une liste ou un tuple.\n",
    "\n",
    "exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(n):\n",
    "    return n**2\n",
    "\n",
    "# pour l'appliquer\n",
    "for i in range(11):\n",
    "    print(f(i))\n",
    "    \n",
    "# ou avec une expression liste\n",
    "[f(i) for i in range(11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les fonctions récursives\n",
    "\n",
    "Que fait le programme suivants?:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def u(n):\n",
    "    if n==0:\n",
    "        return 1\n",
    "    elif n==1:\n",
    "        return 1\n",
    "    else: return u(n-1)+u(n-2)\n",
    "    \n",
    "u(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": 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": {
    "height": "512px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "350px",
    "left": "1px",
    "right": "1475px",
    "top": "107px",
    "width": "302px"
   },
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}