Programmation-Python3-Bases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>Python 3 : Le BN pour s'initier à la programmation</h1></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons découvrir les bases de la programmation en Python 3 en nous appuyant sur un petit programme de calcul et d'affichage des termes d'une suite définie par récurrence tel que :\n",
    "  \n",
    "Soit $(u_n)_{n\\in\\mathbf{N}}$ la suite définie par $\\left\\lbrace\\begin{array}{l} u_n=\\frac{1}{2}\\times u_{n-1}+1 \\text{ pour } n\\gt 1 \\text{ ;} \\\\ u_1=a \\text{ avec } a \\text{, valeur initiale définie par l'utilisateur.}\\\\ \\end{array}\\right.$\n",
    "\n",
    "que l'on peut simuler par ce premier programme :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)\n",
    "for i in range (1,20):\n",
    "    print(\"u\"+str(i)+\" = \"+str(u))\n",
    "    u=0.5*u+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **1)** Exécuter ce programme en sélectionnant sa cellule puis en frappant les touches **`<Alt+Entrée>`** et décrire ce qu'il réalise dans la cellule nouvellement créée en la basculant du type **`Code`** au type [**`Markdown`**](MarkDown-Le_BN_pour_rapporter.ipynb) :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***  \n",
    "> Ce document est un notebook jupyter, si vous n'êtes pas familiarisé avec cet environnement, regardez cette [Introduction](Introduction-Le_BN_pour_explorer.ipynb).  \n",
    "\n",
    ">Les cellules si dessous sont éditables et exécutables. Vous pouvez exécuter une cellule à l'aide du bouton <button class='fa fa-step-forward icon-step-forward btn btn-xs btn-default'></button> ou en utilisant le menu **`Cell>Run...`** ou encore en vous servant des touches :\n",
    "* **`<Maj+Entrée>`** : le code de la cellule est exécuté et le curseur va à la cellule suivante.\n",
    "* **`<Ctrl+Entrée>`** : le code de la cellule est exécuté et le curseur reste sur la même cellule.\n",
    "* **`<Alt+Entrée>`** : le code de la cellule est exécuté et le notebook crée une nouvelle cellule immédiatement après.\n",
    "\n",
    ">Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton <button class='fa fa-plus icon-plus btn btn-xs btn-default'></button>.\n",
    "\n",
    "> Un des avantages principaux des notebooks est de vous permettre de modifier le code que nous avons écrit, et de voir par vous-même comment se comporte le code modifié.  \n",
    "Pour cette raison chaque élève dispose de sa **propre copie** de chaque notebook, ainsi vous pouvez bien sûr apporter toutes les modifications que vous souhaitez à vos notebooks sans affecter ceux des autres élèves et revenir à la version originale en rechargeant un notebook à partir du lien fourni.\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Dans la suite, détaillons un peu toutes les notions d'informatique qui se cachent dans ce premier programme, découvrons plus avant le langage Python 3 et faisons évoluer notre programme...  *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Généralité :\n",
    "[Python](https://fr.wikipedia.org/wiki/Python_(langage)) est un langage de programmation moderne imaginé par [Guido Van Rossum](https://fr.wikipedia.org/wiki/Guido_van_Rossum) , [multi-plateforme](https://fr.wikipedia.org/wiki/Logiciel_multiplate-forme), [open-source](https://fr.wikipedia.org/wiki/Open_source), [généraliste](https://fr.wikipedia.org/wiki/Langage_d%C3%A9di%C3%A9), [orienté objet](https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet) et de [haut niveau](https://fr.wikipedia.org/wiki/Langage_de_haut_niveau).  \n",
    "\n",
    "> Python n'a rien à voir avec le reptile du même nom, mais avec le groupe d'humoristes anglais des années 1970 [Monty Python](https://fr.wikipedia.org/wiki/Monty_Python).\n",
    "\n",
    "C'est un langage à la fois simple et puissant :\n",
    "\n",
    "* simple car facile à apprendre, son code est réputé concis et clair, sa syntaxe est très proche d'une notation algorithmique, base de toute programmation.\n",
    "\n",
    "* puissant car il possède une importante bibliothèque standard et un très grand nombre de paquets complémentaires dédiés au calcul scientifique et aussi pour de nombreux autres domaines d'application. C'est le langage retenu en Classe Préparatoire aux Grandes Ecoles...\n",
    "\n",
    "> Python est considéré comme un langage de conception rapide (Rapid Application Development).\n",
    "\n",
    "C'est un langage **interprété** : pas besoin de compiler tout le programme source en code machine pour l'exécuter. L'interpréteur Python lit et exécute ligne après ligne un script codé en Python. Ce qui est un très gros avantage pour l'apprentissage d'un langage informatique car on peut tester progressivement des portions de code au cours du développement d'un programme plus complet.  \n",
    "\n",
    "Ceci est particulièrement favorisé dans un jupyter notebook qui permet d'exécuter du code cellule après cellule.  \n",
    "Mais attention, il est important que les cellules de code soient évaluées dans le bon ordre. Si vous ne respectez pas l'ordre dans lequel les cellules de code sont présentées, le résultat peut être inattendu.  \n",
    "On rappelle que la façon habituelle de lire l'ensemble du notebook consiste à partir de la première cellule de code à taper **`<Maj+Entrée>`** jusqu'à la fin du notebook, de sorte à bien évaluer toutes les cellules de code.  \n",
    "En fait, évaluer un programme sous forme de notebook revient à le découper en petits fragments, et si on exécute ces fragments dans le désordre, on obtient naturellement un programme différent.\n",
    "\n",
    "<!-- \n",
    "    Toto comments\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les Commentaires :\n",
    "Lorsque l'on rédige un programme informatique il est essentiel de le commenter, pour cela en Python on utilise le caractère **`#`** qui permet d'indiquer que tous les caractères suivants sur la même ligne ne doivent pas être interprétés comme du code d'instruction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########################################################################################\n",
    "# Un programme pour calculer et afficher les 19 premières valeurs d'un suite récurente #\n",
    "#######################################################################################\n",
    "# Affecter une valeur initiale demandée en entrée à une variable u\n",
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)# Convertir la chaine de caractère u en entier\n",
    "for i in range (1,20):# Répéter 19 fois les instructions suivantes\n",
    "    print(\"u\"+str(i)+\" = \"+str(u))# Afficher en sortie la valeur courante\n",
    "    u=0.5*u+1# Calculer la valeur suivante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Voilà un programme qui est maintenant bien mieux renseigné !\n",
    ">\n",
    "><u>Remarque</u>: Le simple fait d'ajouter un **`#`** permet de désactiver une ligne d'instruction sans avoir à l'effacer. Elle ne sera donc pas prise en compte par Python lors de l'exécution du programme. Aussi, il suffira de la décommenter en enlevant ce **`#`** pour la réactiver plus tard si besoin..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Variables :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la mémoire vive de notre ordinateur, nous créons des boîtes (les variables) dans lesquelles nous mettons des valeurs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maPremiereVariable='Hello World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour déclarer une variable en Python, il suffit de la nommer directement (sans autre mot clé comme var, int, ...).  \n",
    "Pour affecter une valeur à la variable on utilise l'opérateur d'affectation **`=`** et Python lui attribue de façon dynamique un **type** correspondant à cette valeur.\n",
    "\n",
    "> Depuis  le menu **``Edit > nbextensions config``** cocher la case **``Variable Inspector``** puis dans le menu du notebook cliquer sur le bouton <button class='fa fa-crosshairs icon-crosshairs btn btn-xs btn-default'></button> pour faire apparaitre la fenêtre de suivie des variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le premier programme qu'écrit tout apprentis programmeur est le fameux [\"Hello World!\"](https://fr.wikipedia.org/wiki/Hello_world), pour ce faire, exécutez ces deux premières intructions précédente puis suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maPremiereVariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Une ligne de code <=> une instruction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un programme informatique est une séquence d'instructions. <img src=\"https://ericecmorlaix.github.io/img/Sequence.svg\" width=\"15%\">\n",
    "\n",
    "L'instruction 3 sera exécutée seulement après l'exécution de l'instruction 2. L'ordre des instructions est donc important.\n",
    "\n",
    "> Dans de nombreux langages de programmation comme Java, C, PHP ou JavaScript, les instructions sont séparées par un point-virgule.\n",
    ">\n",
    "> On observe qu'il n'y a pas de **`;`** à la fin d'une instruction Python, c'est donc le retour à la ligne qui marque la fin de l'instruction et donc le début de la suivante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> En réalité Python autorise le **`;`** pour séparer des instructions et permet ainsi d'écrire une séquence d'instructions sur une même ligne tel que :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maPremiereVariable='Hello World!';maPremiereVariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Le résultat est bien évidemment le même, mais cette pratique, très rarement utilisée, est à éviter car cela devient vite illisible.  \n",
    "Elle est à réserver pour des tests temporaires pour son coté pratique car il suffit alors d'un seul **`#`** pour désactiver toute une séquence..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Type :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction **`type()`** renvoie le type de la variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(maPremiereVariable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maSecondeVariable=5\n",
    "maSecondeVariable, type(maSecondeVariable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maTroisiemeVariable=5.0\n",
    "maTroisiemeVariable, type(maTroisiemeVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Voici donc quelques types de variables :\n",
    "* **`str`** pour string, une chaine de caractères alphanumériques ;\n",
    "* **`int`** pour integer, un nombre entier ;\n",
    "* **`float`** un nombre [flottant](https://fr.wikipedia.org/wiki/Virgule_flottante), représentant un nombre réel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrée de données :\n",
    "\n",
    "Il est parfois nécessaire de demander à l'utilisateur d'entrer des données pour attribuer une valeur à une variable. On utilise pour cela la fonction **`input()`**.\n",
    "> Exécuter cette cellule plusieurs fois pour essayer avec des entrées de différents types..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maVariable=input(\"Entrer une valeur d'un type quelconque : \")\n",
    "maVariable, type(maVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On observe que le type renvoyé par cette cellule est toujours une chaines de caractères alphanumériques.  \n",
    "Il sera donc nécessaire de changer ce type en nombre pour pouvoir utiliser cette variable dans des opérations de calculs arythmétiques, et inversement pour des opérations sur des chaines de caractères."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Les fonctions de conversion de type qui nous seront utiles ici sont **`int()`**, **`float()`**, **`str()`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maNouvelleVariable=float(input(\"Entrer un réel : \"))\n",
    "maNouvelleVariable, type(maNouvelleVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **2)** Dans la cellule suivante, modifier les deux premières instructions de notre programme pour les résumer sur une ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Opération de calcul sur les nombres :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérateurs arithmétiques de Python 3 sont :\n",
    "\n",
    "| Symbole | Opération    |\n",
    "|---------|--------------|\n",
    "| +       | Addition     |\n",
    "| -       | Soustraction |\n",
    "| *       | Multiplication |\n",
    "| /       | Division     |\n",
    "| //      | Division partie entière |\n",
    "| **      | Puissance |\n",
    "| %       | Modulo       |\n",
    "\n",
    "Pour observer les fonctionnalités de la machine à calculer Python, rendez-vous sur le bloc note [Arithmétique](Arithmetique-Le_BN_pour_calculer.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces opérations arithmétiques s'appliquent aussi entre des variables de type nombre et on peut en mémoriser le résultat dans une autre variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 5, 12\n",
    "c = a + b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elles vont donc nous permettre de faire évoluer les variables de type nombre dans notre programme :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = 0.5 * u + 1\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Exécutez la cellule de code précédente en appuyant sur les touches **`<Ctrl+Entrée>`** plusieures fois de suite pour observer l'évolution de notre suite."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le code d'incrémentation **`i++`** ou de décrémentation **`i--`** n'existant pas en Python, on doit donc, après avoir déclaré et initialisé notre variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "utiliser pour incrémenter :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i+=1\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "et pour décrémenter :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i-=1\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Exécutez les deux cellules de code précédentes en appuyant sur les touches **`<Ctrl+Entrée>`** plusieures fois de suite. \n",
    "Essayez aussi avec des valeurs de $pas\\neq1$..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Opération sur les chaines de caractères alphanumériques :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, les chaines de caractère peuvent aussi bien s'écrire entre deux apostrophes (') qu'entre deux guillemets (\").  \n",
    "\n",
    "### Concaténation\n",
    "\n",
    "On peut concaténer deux chaines grâce à l'opérateur **`+`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase= 'Hello'+' '+'World'+' !'\n",
    "phrase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Répétition\n",
    "\n",
    "On peut répéter une chaine grâce à l'opérateur **`*`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mot=\"to\"*2\n",
    "mot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Affichage d'un résultat en sortie :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction **`print()`** permet d'afficher du contenu :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(maPremiereVariable)\n",
    "print(maSecondeVariable)\n",
    "print(maTroisiemeVariable)\n",
    "print(0x1A)\n",
    "print(0b1100)\n",
    "print(\"Le\",\"lycée\",\"Notre\",\"Dame\",\"du\",\"Mur\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On observe que les chaines de caractères s'affichent sans guillemets  \n",
    "et qu'un nombre indiqué en hexadécimal ou en binaire est affiché en décimal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction **`print()`** admet deux arguments interessants :  \n",
    "\n",
    "* **`sep`**  qui permet de séparer les valeurs par un texte de votre choix.  Par défaut le séparateur est un espace **`\" \"`**.\n",
    "* **`end`** qui permet d'ajouter à la fin un texte de votre choix. Par defaut la fin de ligne est un retour à la ligne **`\"\\n\"`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(maPremiereVariable, end=\" | \")\n",
    "print(maSecondeVariable, end=\" | \")\n",
    "print(maTroisiemeVariable, end=\" | \")\n",
    "print(0x1A, end=\" | \")\n",
    "print(0b1100)\n",
    "print(\"Le\",\"lycée\",\"Notre\",\"Dame\",\"du\",\"Mur\", sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher un résultat avec du texte combiné avec des variables, il existe plusieurs méthodes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u,i=15,1\n",
    "print(\"u\",i,\" = \",u,sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Par défaut sep est un espace, si on souhaite que l'indice soit acollé à la variable u, il faut redéfinir sep... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u,i=15,1\n",
    "print(\"u\"+str(i)+\" = \"+str(u))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Il faut convertir les nombres en **`string`** pour pouvoir les **concaténer** avec du texte."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant Python 3.6, le plus élégant consistait à utiliser la méthode **`format()`**, en voici un exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=4\n",
    "b=5\n",
    "print(\"Le produit de {0} par {1} est {2}\\nLa division de {1} par {0} donne {3}\".format(a,b,a*b,b/a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On remplace **`{ }`** par le contenu de la variable. Peu importe son type, le résultat sera affiché."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depuis Python 3.6, on peut utiliser les **`f-strings`** pour formatter une chaine de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=4\n",
    "b=5\n",
    "print(f\"Le produit de {a} par {b} est {a*b}\\nLa division de {b} par {a} donne {b/a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **3)** Proposez un code utilisant la fonction **`format()`** et un autre utilisant les **`f-strings`** qui produisent le même affichage que les deux premières méthodes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u,i=15,1\n",
    "print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Les boucles de répétitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions qui ne sont inscrites qu'une seule fois dans le code.\n",
    "<img src=\"https://ericecmorlaix.github.io/img/BoucleFor.svg\" width=\"25%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe différentes structures de boucles en programmation Python, voici celle d'une boucle while (TANT QUE) :\n",
    "``` python\n",
    "Initialisation\n",
    "# Début de la boucle\n",
    "while Condition :\n",
    "\tInstruction 1\n",
    "\tInstruction 2\n",
    "\t...\n",
    "    Dernière Instruction\n",
    "    Modification\n",
    "# fin de la boucle et suite du programme\n",
    "```\n",
    "Les instructions inscrites dans la boucle forment un bloc d'instructions. Elles seront répétées tant que la condition de répétition est vrai.  \n",
    "Dès que la condition de répétition est fausse le programme sort de la boucle et se poursuit au delà.  \n",
    "L'initialisation déclare une variable et lui affecte une valeur initiale par exemple **`i = 0`**.\n",
    "La modification fait évoluer cette variable de façon régulière à chaque tour de boucle, par exemple par incrémentation **`i+=1`**.\n",
    "La condition consiste donc à faire un test binaire (vrai ou faux) sur la valeur de la variable **`i`**. Puisque **`i`** évolue à chaque tour de boucle, le résultat du test deviendra donc faux au bout d'un nombre fini d'itération.  \n",
    "Ce test s'appuie sur des opérateurs relationnels afin d'établir une comparaison entre la variable **`i`** et la valeur limite de répétition, par exemple **`i < 8`**.\n",
    "\n",
    "Ce qui donne par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "print('Début de la boucle')\n",
    "while i<8 :\n",
    "    print('    Mon')\n",
    "    print('    Bloc')\n",
    "    print(\"    d'instructions\")\n",
    "    i+=1\n",
    "    print('   ',i)\n",
    "print('Fin de la boucle, prêt pour la suite du programme')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indentation obligatoire\n",
    "\n",
    "Python oblige donc le développeur à structurer son code a l'aide des **indentations** : ce sont elles qui, après les **`:`**, détermineront les limites du bloc de la séquence d'instructions répétées dans la boucle et non pas les accolades comme dans la majorité des langages comme par exemple en JavaScript:\n",
    "``` javascript\n",
    "for (initialisation ; condition ; modification) {\n",
    "\tInstruction 1 ;\n",
    "\tInstruction 2 ;\n",
    "\t... ;\n",
    "}\n",
    "```\n",
    "> L'indentation n'est donc pas ogligatoire dans tous les langages informatiques. Par exemple en Javascript on pourrait programmer tel que :\n",
    ">\n",
    ">``` javascript\n",
    ">for(var i=0;i<8;i++){ellipse(positionX+entraxe*i,positionY,diametre,diametre);}\n",
    ">```  \n",
    "> Ce qui est bien évidemment illisible pour un humain \"normal\"...\n",
    "\n",
    "Python oblige donc par nature à produire du code clair et lisible donc facilement maintenable..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">_Nostalgiques des accolades, exécutez l'instruction  suivante :_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import braces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> _et observez que les développeurs de Python, avec ce genre d'\"easter egg\", ne manquent pas d'humour à l'instar des Monty..._\n",
    ">_https://stackoverflow.com/questions/17811855/syntax-error-not-a-chance_\n",
    ">\n",
    "> Essayer aussi avec :\n",
    "```python\n",
    "import this\n",
    "```\n",
    "```python\n",
    "import __hello__\n",
    "```\n",
    "```python\n",
    "import antigravity\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérateurs relationnels, les comparateurs :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "| Symbole | Opération |\n",
    "|---------|-----------|\n",
    "| ==      | égal      |\n",
    "| !=      | différent |\n",
    "| <       | inférieur |\n",
    "| >       | supérieur |\n",
    "| <=      | inférieur ou égal |\n",
    "| >=      | supérieur ou égal |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces opérateurs permettent de faire des tests conditionnels :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition1=(0==1)\n",
    "condition1,type(condition1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition2=(0<=1)\n",
    "condition2,type(condition2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On découvre là un nouveau type de variable **`bool`** pour booléen, leur valeur est soit **`True`** soit **`False`**.\n",
    "> \n",
    "> Nous verrons plus tard plus en détails la logique booléenne que l'on doit à [George](https://fr.wikipedia.org/wiki/George_Boole)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **4)** Modifier le programme pour qu'il affiche le même résultat mais en utilisant une boucle **`while`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########################################################################################\n",
    "# Un programme pour calculer et afficher les 19 premières valeurs d'un suite récurente #\n",
    "#######################################################################################\n",
    "# Affecter une valeur initiale demandée en entrée à une variable u\n",
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)# Convertir la chaine de caractère u en entier\n",
    "for i in range (1,20):# Répéter 19 fois les instructions suivantes\n",
    "    print(\"u\"+str(i)+\" = \"+str(u))# Afficher en sortie la valeur courante\n",
    "    u=0.5*u+1# Calculer la valeur suivante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La boucle for\n",
    "La boucle **_for_** prend ses valeurs dans un ensemble itératif :\n",
    "\n",
    "```python\n",
    "for variable in liste_valeurs\n",
    "```\n",
    "À chaque itération la variable prendra pour valeur un élément de la liste.\n"
   ]
  },
  {
   "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\n",
    "```python\n",
    "for i in range(m,n,p):\n",
    "```  \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": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **5)** Dans la cellule ci-dessous, modifier notre programme pour qu'il calcule les 30 premiers termes de la suite u."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########################################################################################\n",
    "# Un programme pour calculer et afficher les 19 premières valeurs d'un suite récurente #\n",
    "#######################################################################################\n",
    "# Affecter une valeur initiale demandée en entrée à une variable u\n",
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)# Convertir la chaine de caractère u en entier\n",
    "for i in range (1,20):# Répéter 19 fois les instructions suivantes\n",
    "    print(\"u\"+str(i)+\" = \"+str(u))# Afficher en sortie la valeur courante\n",
    "    u=0.5*u+1# Calculer la valeur suivante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **6)**  Créer un nouveau programme pour qu'il calcule les 20 premiers termes de la suite v définie par récurrence tel que :\n",
    "  \n",
    "Soit $(v_{n})_{n\\in\\mathbf{N}}$ la suite définie par $\\left\\lbrace\\begin{array}{l} v_{n+1}=\\frac{1}{2}\\times (v_{n}+\\frac{5}{v_{n}}) \\text{ pour } n\\gt 0 \\text{ ;} \\\\ v_0=a \\text{ avec } a \\text{, valeur initiale définie par l'utilisateur.}\\\\ \\end{array}\\right.$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **7)**  Que se passe t-il si l'utilisateur entre une valeur non entière?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **8)**  Modifier le programme pour que l'utilisateur puisse saisir une valeur réelle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **9)** On souhaite l'affichage des termes de rang 20 à 50. Modifier le programme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les alternatives, si ...  alors ...  sinon :\n",
    "\n",
    "```python\n",
    "if condition:\n",
    "    # Traitement bloc 1\n",
    "else:\n",
    "    # Traitement bloc 2\n",
    "```\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",
    "\n",
    "```python\n",
    "if condition:\n",
    "    # Traitement bloc 1\n",
    "elif:\n",
    "    # Traitement bloc 2\n",
    "else:\n",
    "    # Traitement bloc 3\n",
    "```\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": [
    "##  Les fonctions :\n",
    "\n",
    "Les fonctions se définissent de la façon suivante :\n",
    "\n",
    "```Python\n",
    "def maFonction(parametre1, parametre2):\n",
    "    instructions\n",
    "    return valeur1, valeur2\n",
    "```\n",
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max(x,y):\n",
    "    if (x>y):\n",
    "        return x\n",
    "    else :\n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour l'utiliser, il faut l'appeler :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(6,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ensuite la rapeller autant de fois qu'on le souhaite :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(-9,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pour aller plus loin :\n",
    "\n",
    "## les fonctions récursives :\n",
    "\n",
    "Que fait le programme suivants?:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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": "markdown",
   "metadata": {},
   "source": [
    "## La gestions des erreurs, les exeptions :\n",
    "\n",
    "Gérer une exeption permet d'intercepter une erreur pour éviter un crash, un arrêt non souhaité du programme.\n",
    "\n",
    "La séquence normale d'instructions est placé dans un bloc ``try``.\n",
    "Si une erreur est détectée (si une exeption est levée), elle est traitée dans le bloc ``except`` approprié.\n",
    "\n",
    "````python\n",
    "try :\n",
    "    ... # séquence normale d'exécution\n",
    "````\n",
    "````python    \n",
    "except NomErreur : # préciser le nom de l'erreur à capter\n",
    "    \n",
    "    ... # traitement à faire en cas d'erreur    \n",
    "\n",
    "````\n",
    "Tester le script de la cellule suivante en entrant une chaine de caractère, puis réessayer avec un nombre entier..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    try:\n",
    "        x = int(input(\"Entrer un nombre : \"))\n",
    "        print(f'{x} est un nombre valide. Merci !')\n",
    "        break\n",
    "    except ValueError:\n",
    "        print(\"Oops!  Ceci n'est pas un nombre valide, recommencez...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qu'est-ce que cela donne avec le nombre 1.5 ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<button class='fa fa-graduation-cap icon-graduation-cap btn btn-xs btn-default'></button> **10)** Reprenez les programmes précédents en utilisant les fonctions et en gérant les erreurs potentielles..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L'outil Python tutor :\n",
    "\n",
    "[Python tutor](http://pythontutor.com/) permet de visualiser pas à pas ce que fait votre script.\n",
    "\n",
    "Il est possible de l'utiliser dans un notebook jupyter pour celà il faut :\n",
    "1. l'installer (si ce n'est pas déjà fait) : ``%pip install metakernel``\n",
    "1. puis exécuter les instructions de la cellule suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from metakernel import register_ipython_magics\n",
    "register_ipython_magics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. inscrire la commande ``%%tutor`` devant le script à tester dans la cellule :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%tutor\n",
    "\n",
    "u=input(\"entrer la valeur du premier terme u1:\")\n",
    "u=int(u)\n",
    "for i in range (1,20):\n",
    "    print(\"u\"+str(i)+\" = \"+str(u))\n",
    "    u=0.5*u+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ressources :\n",
    "\n",
    "- [Documentation python 3.7](https://docs.python.org/fr/3.7/tutorial/index.html) \n",
    "- [France IOI](http://www.france-ioi.org/algo/chapters.php)\n",
    "- [Fabrice DUMONT](http://python.lecoinduprogrammeur.org/category/python-decouvertes/) \n",
    "- [Jean-Daniel Bonjour](https://enacit1.epfl.ch/introduction-python/)\n",
    "- [Débuter avec python au lycée](http://python.lycee.free.fr/blog/)\n",
    "- \n",
    "-   \n",
    "- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Aucun(e)",
  "hide_input": false,
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "100px",
    "left": "980px",
    "top": "196.71px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "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": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}