ISN-Python3-Initiation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3 : Le BN pour s'initier à la programmation scientifique"
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "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": [
    "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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."
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "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",
    "> En 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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(maPremiereVariable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maSecondeVariable=5\n",
    "maSecondeVariable, type(maSecondeVariable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maTroisiemeVariable=5.0\n",
    "maTroisiemeVariable, type(maTroisiemeVariable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maQuatriemeVariable=1+2j\n",
    "maQuatriemeVariable, type(maQuatriemeVariable)"
   ]
  },
  {
   "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 ;\n",
    "* **`complex`** un nombre complexe."
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maNouvelleVariable=float(input(\"Entrer un réel : \"))\n",
    "maNouvelleVariable, type(maNouvelleVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "utiliser pour incrémenter :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i+=1\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "et pour décrémenter :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mot=\"to\"*2\n",
    "mot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> "
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(maPremiereVariable)\n",
    "print(maSecondeVariable)\n",
    "print(maTroisiemeVariable)\n",
    "print(maQuatriemeVariable)\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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(maPremiereVariable, end=\" | \")\n",
    "print(maSecondeVariable, end=\" | \")\n",
    "print(maTroisiemeVariable, end=\" | \")\n",
    "print(maQuatriemeVariable, 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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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`** :"
   ]
  },
  {
   "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": [
    "2) 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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "u,i=15,1\n",
    "print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Boucle 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": {
    "collapsed": true
   },
   "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 en Javascript on pourrait donc programmer comme celà :\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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import braces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> _et observez que les développeurs de Python, ne manquent pas d'humour à l'instar des Monty..._"
   ]
  },
  {
   "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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "condition1=(0==1)\n",
    "condition1,type(condition1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "condition2=(0<=1)\n",
    "condition2,type(condition2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On découvre là un nouveau type **`bool`** pour booléen que l'on doit à [George](https://fr.wikipedia.org/wiki/George_Boole)\n",
    "\n",
    "## Les booléens et les opérateurs logiques\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_**.\n",
    "\n",
    "Pour combiner les tests, on utilise les opérateurs booléens (ou connecteurs logiques): \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>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "1>2 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2>1 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "1>2 or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) 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": {
    "collapsed": true
   },
   "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",
    "**for *variable* in *liste_valeurs* **. À 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 ***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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(0,4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(0,6,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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": {
    "collapsed": true
   },
   "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": [
    "4) 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": {
    "collapsed": true
   },
   "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": [
    "5) 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": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Que se passe t-il si l'utilisateur entre une valeur non entière?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7) Modifier le programme pour que l'utilisateur puisse saisir une valeur réelle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8) On souhaite l'affichage des termes de rang 20 à 50. Modifier le programme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les structures de boucle et de test\n",
    "\n",
    "## Les structures de test\n",
    "\n",
    "### 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": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=3\n",
    "if a>1:\n",
    "    print('a>1')\n",
    "else:\n",
    "    print('a<=2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9) Comparer les derniers termes avec la racine carrée de 5. Que remarquez-vous?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10) Modifier le programme pour qu'il affiche une valeur approchée de la racine carrée d'un nombre entier $E$, saisi par l'utilisateur en début d'exécution.\n",
    "On pourra se passer de la saisie du premier terme que l'on prendra égal à $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11) Pour obtenir une valeur approchée de la racine carrée de $E$ avec une erreur inférieure ou égale à $10^{-P}$, avec $P$ entier positif, on pourra se référer au sujet 9 page 152 (ABC bac 2018-France Métropolitaine, septembre 2012) et compléter l'algorithme proposé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pour aller plus loin \n",
    "\n",
    "##  Les fonctions\n",
    "\n",
    "Les fonctions se définissent de la façon suivante\n",
    "````Python\n",
    "def maFonction(parametre1, parametre2):\n",
    "    instructions\n",
    "    return valeur1, valeur2\n",
    "```\n",
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def max(x,y):\n",
    "    if (x>y):\n",
    "        return x\n",
    "    else :\n",
    "        return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(6,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(-9,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": [
    "12) Reprenez les programmes précédents en utilisant les fonctions..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les types liste, tuple, tableau, et dictionnaire :\n",
    "Python dispose de plusieurs type pour gérer des ensembles de données, constantes comme variables, et potentiellement de différents types. Ce sont de véritables couteaux Suisses que l'on peut utiliser dans tous les domaines de l'informatique.  \n",
    "Ici nous ne faisons qu'une première présentation d'introduction à ces types : le minimum vital pour pouvoir les utiliser dans ce BN. Nous les retrouverons de fassons plus exhaustive et explicite dans les autres bloc-notes par domaine d'application..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### Les listes :\n",
    "Une liste est un ensemble d'éléments éventuellement de différents types. Une liste se définit à l'aide 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 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maListe=[3.14, \"cours isn\", 1+1j, 5]\n",
    "maListe[1], type(maListe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour ajouter un élément à une liste on utilise la méthode **``append()``**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maListe.append(\"toto\")\n",
    "maListe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut modifier un élément en particulier :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maListe[4]=\"titi\"\n",
    "maListe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### Les tuples \n",
    "Les tuples sont des listes particulières, on ne peux pas les modifier. 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,)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTuple=(3.14, \"cours isn\", 1+1j, 5)\n",
    "monTuple[1], type(monTuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On ne peut pas modifier un tuple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTuple[1]=\"toto\"\n",
    "monTuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut convertir une liste en tuple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monNouveauTuple = maListe\n",
    "monNouveauTuple, type(monNouveauTuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et inversement, un tuple en liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maNouvelleListe = list(monTuple)\n",
    "maNouvelleListe, type(maNouvelleListe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### Les dictionnaires\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**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monDictionnaire = {'zero':0, 'un':1, 'deux':2,'trois':3}\n",
    "monDictionnaire['zero'], type(monDictionnaire)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### Les tableaux :\n",
    "Les tableaux sont en général des listes de listes pas obligatoirement homogène en taille, ni en type :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTableau= [[1,2,3,4],[\"toto\",\"titi\",\"tata\"], [-3.14, 0.5, 1, 2.35, 6.48]]\n",
    "monTableau[1][0], type(monTableau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La bibliothèque **``numpy``** permet de gérer des tableaux numériques homogènes, des matrices..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--\n",
    "Approximation de la racine carrée d'un nombre entier\n",
    "\n",
    "# Demander à l'utilisateur de saisir une valeur initiale\n",
    "# La valeur récupérer en entrée est de type chaine de caractères\n",
    "v=input(\"entrer la valeur du premier terme v1:\")\n",
    "# v=int(v) # Pour convertir en valeur entière\n",
    "v=float(v) # Pour convertir en valeur réelle\n",
    "# for i in range (1,21): # Boucle 20 fois\n",
    "for i in range (1,51): # Boucle 50 fois\n",
    "# print(\"v\"+str(i)+\" = \"+str(v))# Affiche la valeur courante sans condition\n",
    "  if (i>19):# Condition d'affichage de la valeur courante\n",
    "   print(\"v\"+str(i)+\" = \"+str(v))# Affiche la valeur courante\n",
    "  v=3*v-0.5 # Calcule la valeur suivante\n",
    "\n",
    "La Suite de Fibonacci est définie comme suit:\n",
    "\n",
    "Le premier terme est égal à 1\n",
    "Le deuxième terme est égal à 1\n",
    "A partir du troisième terme, chaque terme est égal à la somme des deux termes précédents.\n",
    "\n",
    "Ainsi la suite de Fibonacci commence par : 1, 1, 2,3,5,8,13, 21,34,55,89, 144....\n",
    "\n",
    "Cette suite possède de nombreuses propriétés intéressantes.\n",
    "\n",
    "Par exemple : \n",
    "\n",
    "Propriété 1:  Le quotient d'un terme par le terme précédent tend vers le nombre d'or.\n",
    "ou encore\n",
    "Propriété 2: La somme des carrés des termes de la suite jusqu'au rang n est égal au produit des termes de rang n et n+1.\n",
    "\n",
    "Ces propriétés peuvent être démontrées, mais il peut être intéressant de les vérifier par simulation.\n",
    "\n",
    "C'est l'objet de ce TP.\n",
    "\n",
    "1) Compléter le programme proposé pour qu'il affiche les n premiers termes de la suite de Fibonacci, n étant une valeur entière saisie par l'utilisateur à l'invitation du programme.\n",
    "\n",
    "2) Ajouter ensuite les instructions nécessaires pour qu'il affiche le quotient du dernier terme (rang n ) par le précédent.\n",
    "En choisissant n assez grand, vous pourrez ainsi visualiser si la propriété 1 semble vraie.\n",
    "\n",
    "3) Ajouter ensuite les instructions nécessaires pour afficher la somme des carrés des termes jusqu'au rang n et comparer ce résultat au produit des termes de rang n et n+1.\n",
    "Vous pourrez ainsi vérifier si la propriété 2 est vérifiée au rang n.\n",
    "\n",
    "#SUITE DE FIBONACCI\n",
    "\n",
    "#Invitation à saisir le rang du dernier terme souhaité\n",
    "n=input(\"saisir n, le rang du dernier terme que vous souhaitez obtenir\")\n",
    "#l'instruction input renvoie une chaîne de caractères que l'on convertit en nombre entier\n",
    "n=int(n)\n",
    "#initialisation par la donnée des deux premiers termes\n",
    "u=1\n",
    "v=1\n",
    "# On commence une boucle qui va calculer et afficher les valeurs successives des termes de la suite \n",
    "for i in range(3,n):\n",
    "  w=u+v\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ressources :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [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",
    "* http://www.jdhp.org/docs/atelier_initiation_python_part1/main.html#168  \n",
    "*   \n",
    "* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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
}