{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithmique et Programmation\n",
    "\n",
    "> premiers pas en Python\n",
    "\n",
    "- toc: true\n",
    "- badges: true\n",
    "- comments: false\n",
    "- categories: [python, ISN]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "215131e5db20b1a114b21e038526e274",
     "grade": false,
     "grade_id": "cell-c3788f7f106ee30a",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Premiers scripts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b1c5ab19b4ce846c3354d4553158a350",
     "grade": false,
     "grade_id": "cell-05d842fa33fab291",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Nous allons commencer à rédiger des petits programmes Python. Bien entendu, ceux-ci seront au début complètement dépourvus d'intérêt. Au fur et à mesure, les choses gagneront en consistance et en efficacité pour atteindre des problèmes plus complexes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3c78a55d046d0ac584d821147841c641",
     "grade": false,
     "grade_id": "cell-99f60de45d7a80dd",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Les variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "cae4cbc429fa6dbec38bf6ecbebcafaf",
     "grade": false,
     "grade_id": "cell-a0511538b9dfd0a3",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Les variables permettent de stocker des valeurs. Elles sont un moyen de nommer les informations pour une utilisation dans un programme.\n",
    "Chaque variable a un nom ; un exemple de nom de variable que nous utiliserons est <B>monNombre</B>. Pour stocker de l'information dans une variable, nous écrivons une commande en utilisant le signe égal (=) dans la manière suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "5e11a034e606ed26d73c41ddb7accc29",
     "grade": false,
     "grade_id": "cell-3f37c69352ff7189",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "monNombre = 13\n",
    "print(monNombre+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9b1fcdd889d8a2dc2f28e8b60c494a5a",
     "grade": false,
     "grade_id": "cell-b85bf87c0f8d8b54",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "L'instruction très utile \"a=a+1\" qui n'a aucun sens mathématique est très utile en informatique : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e187e5a58f12fb6b8d886042ac7d43a1",
     "grade": false,
     "grade_id": "cell-9510589796a4a7bb",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a=3\n",
    "a=a+1\n",
    "print(a)\n",
    "print(A) # la casse (distinction entre majuscules et minuscules) est prise en compte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "086e40d6e9a7173c7295bdd4e08cefee",
     "grade": false,
     "grade_id": "cell-775d5ea1170643dc",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "En première ligne, la valeur 3 est affectée dans la place mémoire \"a\". \n",
    "En deuxième ligne, l'ordinateut calcule \"a+1\" puis l'affecte dans la place mémoire \"a\" : la variable \"a\" devient donc égale à 4. On vient d'augmenter (on dit aussi incrémenter) la variable \"a\" d'une unité.\n",
    "La dernière ligne confirme le fait que le langage machine différencie les lettres minuscules et majuscules, d'où le message d'erreur.\n",
    "\n",
    "Regardez l'exemple suivant. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6047f732604e74c701504690d5b9decb",
     "grade": false,
     "grade_id": "cell-66c4428ddeed1f15",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a=5\n",
    "b=3\n",
    "b=2*b-a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bce0e28ee6317a2bd3ea7feffd8f67cc",
     "grade": false,
     "grade_id": "cell-a0bf803360638ec9",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Quelle est la valeur prise par la variable $b$? Répondez dans la cellule ci-dessous. Vous indiquerez votre réponse dans la variable $ma\\_reponse$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Complétez ci-dessous\n",
    "ma_reponse = ...\n",
    "\n",
    "# Test automatique de la réponse. \n",
    "# En cas d'erreur, Python vous le fera savoir !\n",
    "# Si c'est bon, la cellule ne renverra rien\n",
    "assert ma_reponse == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "21a6d199fe57a83e2523eb86df4eb5c0",
     "grade": false,
     "grade_id": "cell-e8e8f2d751d397e8",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Complément** : vous trouverez tout au long de ces classeurs ces commandes python ***assert***. \n",
    "\n",
    "***assert*** permet de vérifier une condition. Si la condition est vraie, il ne provoque aucun retour. Si au contraire le résultat du test est faux, assert provoque un message d'erreur Python (ce qu'on appelle une exception). \n",
    "\n",
    "Cela permet de vous autocontrôler : en validant ces cellules contenant le mot assert, vous pourrez vérifier par vous même que vous avez bien répondu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a862da9fb5c3561fa6cc3f683cb0816f",
     "grade": false,
     "grade_id": "cell-bac035a3bf5d4d26",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Les différents types de variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fec5b758066bc05d20263dab90823bdf",
     "grade": false,
     "grade_id": "cell-81378107b957dbdf",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Les variables peuvent contenir différents types d'informations. On dit qu'elles sont de type :\n",
    "- *int* : entiers (ex : -2 ; 5)\n",
    "- *float* : décimal (ex -2.0 ; 2e6=2000000.0)\n",
    "- *str* : chaîne de caractère (ex 'Bonjour' ; \"Autre exemple\" ; \"2+3\" ; \"5\")\n",
    "- *bool* : Booléen : Vrai ou Faux. (ex : 2==3, False, 3<4)\n",
    "- *list* : Tableau ou liste (ex : [1,'toto', 2.0] ; [[1,2],[3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "39eba4e84645ead25670b3a8ecbe31a7",
     "grade": false,
     "grade_id": "cell-60fc2ae5b1260464",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a = 5.2\n",
    "b = 12\n",
    "c = \"Je suis une chaîne de caractère\"\n",
    "d = [1, 4.2, \"je suis un tableau\"]\n",
    "e = type(b)==int\n",
    "# remarquez pour e la différence entre les opérateurs = et =="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "c358cf265599d449a8f45269ac8053cc",
     "grade": false,
     "grade_id": "cell-bedcb48ffe2743a7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(b) == int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "db42344dbd7f5da35349cbfe65bd9130",
     "grade": false,
     "grade_id": "cell-a22d2e935699dbab",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Complétez les types dans la cellule suivante selon le modèle ci-dessus. Vous utiliserez les types énumérés plus haut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert type(a) == ...\n",
    "assert type(a/b) == ...\n",
    "assert type(c) == ...\n",
    "assert type(d) == ...\n",
    "assert type(e) == ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "32386d3a04e9c39661bc832c9fd44c38",
     "grade": false,
     "grade_id": "cell-1484380431f56099",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Comme vous pouvez le voir, contrairement à d'autres langages comme le langage C ou java, Python devine tout seul le type des variables. Il est inutile de lui préciser par avance. Cela est extrèmement pratique !\n",
    "\n",
    "Même si ce n'est pas conseillé, on peut aussi changer de type en cours de route :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "2c6e3648eea028597380a06aee5acf2b",
     "grade": false,
     "grade_id": "cell-0be64e6af32fa679",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a=\"Je suis une chaîne\"\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3bf087dcfa247acc1a4e7629a6611e01",
     "grade": false,
     "grade_id": "cell-f8eee483659a7c5b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a=12 # et maintenenant je suis un nombre !!!\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a3222585f366b3a1ba31a0ed1bb2efdd",
     "grade": false,
     "grade_id": "cell-4cdfe5b9d12e6515",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Affectations simultanées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "68f533aca68bff430a93d60d61be1174",
     "grade": false,
     "grade_id": "cell-8b31eff29a5ceeda",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Une application très classique de l'affectation simultanée est l'échange du contenu de deux variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "211c62a60e69c13901599b934d1bf551",
     "grade": false,
     "grade_id": "cell-3d04cbc375f572e5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a, b = 32, 10\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = b, a\n",
    "\n",
    "# complétez les lignes ci-dessous avec les valeurs des variables a et b\n",
    "assert a == ...\n",
    "assert b == ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f192ab53729ca06d7b30be88b9bd038a",
     "grade": false,
     "grade_id": "cell-4d25c2270b7fa2ca",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "L'affectation multiple \"a, b = b, a\" permet en une seule ligne d'échanger les contenus des variables a et b. Tentons maintenant d'échanger deux variables a et b sans affectation multiple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=12\n",
    "b=30\n",
    "\n",
    "a=b\n",
    "b=a\n",
    "# complétez les lignes ci-dessous avec les valeurs des variables a et b\n",
    "assert a == ...\n",
    "assert b == ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a6d93f9d9ad3bbebb4040abd5b7d7dc8",
     "grade": false,
     "grade_id": "cell-e32e8fc095729f3b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "On a affecté à la variable b une valeur non numérique, mais une chaîne de caractère (entre guillemets). La troisième ligne confirme l'affectation pour \"a\" et \"b\".\n",
    "Cependant, la quatrième ligne efface de la mémoire la valeur de \"a\", de sorte que \"a\" devient égal à \"b\". L'instruction \"b=a\" est alors inutile. \n",
    "\n",
    "Pour contourner ce problème, il faut avoir recours à une mémoire temporaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bd6f6dda341af1ef306ec99aaafbb1c1",
     "grade": false,
     "grade_id": "cell-6bada345d486da81",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "a = 12\n",
    "b = 30\n",
    "\n",
    "memoire_temp=a\n",
    "a = b\n",
    "b = memoire_temp\n",
    "\n",
    "assert a == 30\n",
    "assert b == 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "06bc74992be18797d12355a819a29d91",
     "grade": false,
     "grade_id": "cell-8625e52c5bb74440",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "L'absence d'erreurs à l'exécution de la cellule montre que le contenu de $a$ et $b$ a bien été échangé"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6a06064985629437fc7b04d43cd21b9e",
     "grade": false,
     "grade_id": "cell-6c8be03ed072ad6f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Les fonctions\n",
    " Les fonctions permettent de décomposer un programme complexe en une série de sous-programmes plus simples. De plus, les fonctions sont réutilisables : si nous disposons d'une fonction capable de calculer une racine carrée, par exemple, nous pouvons l'utiliser un peu partout dans notre programme sans avoir à la réécrire à chaque fois (on parle de factorisation du code)\n",
    "\n",
    "La notion de fonction en informatique est comparable à la notion de fonction en mathématiques.\n",
    "![](https://pixees.fr/informatiquelycee/n_site/img/nsi_python_2.png)\n",
    "Si nous avons $y = 3x+2$, pour une valeur donnée de $x$, nous aurons une valeur de $y$.\n",
    "\n",
    "**Exemple** : $x=4$ donc $y= 14$ ($y = 3.4+2=14$, attention ici le point correspond au signe \"multiplié\").\n",
    "\n",
    "La fonction en informatique est basée sur la même idée :\n",
    "![](https://pixees.fr/informatiquelycee/n_site/img/nsi_python_3.png)\n",
    "Voici la syntaxe employée en Python pour définir une fonction :\n",
    "``` python\n",
    "def nom_de_la_fonction(parametre):\n",
    "\tinstruction_1\n",
    "\tinstruction_2\n",
    "\treturn y\n",
    "suite programme```\n",
    "La fonction renvoie la valeur contenue dans la variable y.\n",
    "\n",
    "***ATTENTION*** : Notez bien la présence du décalage entre la première ligne et les lignes suivantes. Ce décalage est appelé indentation, l'indentation permet de définir un bloc de code. Dans l'exemple ci-dessus, l'indentation nous permet de savoir que \"instruction_1\", \"instruction_2\" et \"return y\" constituent un bloc de code, ce bloc correspond au contenu de la fonction. \"suite programme\" ne fait pas partie de la fonction, car il n'est pas indenté. Pour indenter du code, il y a 2 solutions : mettre 4 espaces ou utiliser une tabulation. En Python il est conseillé d'utiliser les 4 espaces, mais ce n'est pas une obligation. Une chose est sûre, une fois que vous avez choisi une méthode, n'en changé surtout pas au cours d'un même programme ! \n",
    "\n",
    "*source* : https://pixees.fr/informatiquelycee/n_site/nsi_prem_pythonbase.html\n",
    "\n",
    "Dans l'exemple suivant, vous constaterez la similitude entre la syntaxe python et l'écriture mathématique\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "479c9e3683022ee96fd16187aeec4949",
     "grade": false,
     "grade_id": "cell-630d668e788ac684",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Validez cette cellule pour définir la fonctionf\n",
    "def f(x):\n",
    "    y=3*x-2\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f097d0ab0c3c7b5f4bfb93ad54ba8254",
     "grade": false,
     "grade_id": "cell-16b0776752928734",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Validez cette cellule pour invoquer la fonction f (lancer l'exécution du code contenu dans la fonction f) \n",
    "# La valeur 3 va alors prendre la place du paramètre x\n",
    "\n",
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d0cf6617a3ba4c30548633fe5994d580",
     "grade": false,
     "grade_id": "cell-b01b8c0d99dfb88f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Les fonctions jouent un rôle fondamental en informatique. Aucun programme n'est écrit d'un bloc. Imaginez un programme comme OpenOffice qui contient plusieurs centaines de milliers de lignes de codes écrites bout à bout sans structure... \n",
    "\n",
    "Vous devrez prendre l'habitude de concevoir vos propres fonctions pour répondre à un problème donné.\n",
    "\n",
    "Plus tard, nous allons voir la notion d'objet qui est apparu au début des années 80 et qui vient encore enrichir ce concept de fonction. Aujourd'hui tous les langages modernes sont orientés Objet. La programmation par objet a permis l'émergence de systèmes d'exploitation offrant des interfaces graphiques évoluées (Linux, MacOs...). \n",
    "\n",
    "Vous allez vous-même manipuler des objets quand vous allez découvrir la programmation d'interfaces graphiques pour vos projets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9188a60c1d05cd4d80b68616cab18a80",
     "grade": false,
     "grade_id": "cell-8722b8496ded7177",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Instruction conditionnelle Si...Alors...Sinon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "5c535acf0c2528c408f7768844b97354",
     "grade": false,
     "grade_id": "cell-6a25882548fe0ce1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Observez le fonctionnement de la fonction ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "305a8b658ad3c0453cf3775e602fdc9e",
     "grade": false,
     "grade_id": "cell-ceb155d05f10d2d1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "def exemple2(age):\n",
    "    if age >= 18:\n",
    "        return \"vous êtes majeur\"\n",
    "    elif age > 0:\n",
    "        return \"vous êtes mineur\"\n",
    "    else : \n",
    "        return \"menteur !\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9dce016d07a66d405d8fd8395eb3eee1",
     "grade": false,
     "grade_id": "cell-4b55f31ddd06b33f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "- Les clauses ***elif*** et ***else*** sont optionnelles pour la structure ***if***.\n",
    "- Il est possible de mettre autant de ***elif*** que l'on veut si on veut tester de multiples conditions sur une variable.\n",
    "- Il ne peut y avoir au plus qu'une seule clause ***else*** dans une structure conditionnelle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e39f97938ee8156acbbf2cbaca9cc06e",
     "grade": false,
     "grade_id": "cell-bddde39aeaca7631",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Boucle pour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "84b1ef2c35a95af9ed748e842f5486cb",
     "grade": false,
     "grade_id": "cell-376bd01ab271e853",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La syntaxe de la boucle pour est un peu particulière : On dit à une variable de parcourir un certain intervalle.\n",
    "\n",
    "L'intervalle en question est décrit par l'instruction `range(n)`. Les quelques exemples ci-dessous vous illustrent le fonctionnement de cette instruction.\n",
    "\n",
    "L'instruction ***print*** en python permet d'afficher un texte à l'écran. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "dcbdb2e11525baff870dee718cb69f09",
     "grade": false,
     "grade_id": "cell-55448f60a9d5ef38",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(\"je répète 5 fois la même chose. Ici, i=\",i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3e2ee7928cae272465739621da5138d3",
     "grade": false,
     "grade_id": "cell-e14b0ec2598f9e31",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Ce qu'il faut retenir c'est :\n",
    "- que la boucle `for i in range(n)` tournera `n` fois\n",
    "- que la variable `i` prendra les valeurs entières entre 0 et `n-1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "30d8bca346b4155183cd065a993e6f82",
     "grade": false,
     "grade_id": "cell-89f2456f419e4077",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Importance du symbole \":\"\n",
    "Remarquez bien le `:` après le range. Cela marque le début d'un *bloc*.\n",
    "\n",
    "Un *bloc* en python se distingue par le ***décalage par rapport à la marge***. Il permet de délimiter le début etr la fin du contenu de la boucle pour. En effet, contrairement à la calculatrice, il n'y a par de mot clé `end`(TI) ou `next` (casio) pour signifier la fin de la boucle pour.\n",
    "\n",
    "On retrouvera cette notion de bloc également pour les boucles tant que, les tests si... alors... sinon..., les définitions de fonction etc...\n",
    "\n",
    "Soyez donc très attentif à la présence de ces `:` et au décalage de marge qui s'en suit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "0cdad3db63ac14096e68cebd2a2adc74",
     "grade": false,
     "grade_id": "cell-b09c5de40e3cce11",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "On peut paramétrer un peu l'instruction `range` :\n",
    ">    range(1,10)\n",
    "\n",
    "Le compteur commencera à 1 et s'arrêtera à ***9***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "48d387259a825d0b1fcce2df484b6c70",
     "grade": false,
     "grade_id": "cell-3a112f2e0d27f602",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Exemple : Expérimenter et expliquer les valeurs prises par la variable `i` dans la boucle \n",
    ">   for i in range( 3,15,2) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "96ca799880c18ffe9aafa046ac07394e",
     "grade": false,
     "grade_id": "cell-223099d3036d12d5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "for i in range( 3,15,2) :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "319e206d2bbbfd7466b29c256c0a8863",
     "grade": false,
     "grade_id": "cell-20c072c3505b2b1b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Dans la boucle ***pour***, \n",
    "- la variable *i* est initialisée à 3 à 3\n",
    "- la variable *i* augmente d'un pas de 2\n",
    "- la boucle s'arrete quand *i* dépasse la valeur 15-1=14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "4bf7d329f91d140dd5758cf0d92c8e9a",
     "grade": false,
     "grade_id": "cell-4c5be0caf3ecbe9e",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "62931c1bc3a0f2d5d82fa3d188937cbc",
     "grade": false,
     "grade_id": "cell-3936a464efd945a1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "1. Ecrire une fonction ***somme*** qui calcule la somme des entiers jusqu'à $n$ passé en paramètre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "d2eb790aa9b96952237ec81e31b7249b",
     "grade": false,
     "grade_id": "cell-cb351c0f2bdd397b",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def somme(n):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f23714b04d9940bcd704f494f8902603",
     "grade": true,
     "grade_id": "cell-33deeede8d19560e",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert somme(100) == 5050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a193b70260130baed2dacbaaddba48f2",
     "grade": false,
     "grade_id": "cell-fe5e788c48b94044",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "2. En mathématiques, on utilise la fonction ***factorielle*** d'un nombre pour calculer le produit de tous les entiers non nuls entre 1 et ce nombre. Par exemple :\n",
    "\n",
    "Factorielle 5 (que l'on note 5!) se calcule par la formule : $5!=1\\times 2\\times 3\\times 4\\times 5=120$\n",
    "\n",
    "Ecrire une fonction ***factorielle*** prenant en argument un entier et retournant la factorielle de ce nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "e110942a6b7cbcdb8f449c39398d1d29",
     "grade": false,
     "grade_id": "cell-8f524b70e104d9e9",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def factorielle(n):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ae61517b7815fc943bc3aba8dcc8b3af",
     "grade": true,
     "grade_id": "cell-528b7a01115f5960",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Testez votre fontion\n",
    "assert factorielle(5) == 120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "4bdb38641f3d82d057de1f1c1c3b7ae1",
     "grade": false,
     "grade_id": "cell-277d32493ddbcbe8",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Vous avez vu en première l'opérateur ***k parmi n*** noté  ${n} \\choose {k}$ permettant de comptabiliser le nombre de chemins menant à $k$ succès dans une répétition de $n$ expériences Succès/Echec.\n",
    "\n",
    "On peut montrer que ce nombre de chemins peut se calculer facilement au moyen de la fonction factorielle vu plus haut :\n",
    "${n \\choose k }=\\dfrac{n!}{k!(n-k)!}$\n",
    "\n",
    "Ecrire une fonction ***coefbinom*** prenant en argument deux entiers $k$ et $n$ et retournant la valeur de $n \\choose k$.\n",
    "\n",
    "On pourra faire appel à la fonction ***factorielle*** vue ci-dessus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "ed4a28b683b67ba77692f6da43ea7b94",
     "grade": false,
     "grade_id": "cell-8549f334ec8156a6",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def coefbinom (k,n):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8400dcb24094b7275910b52d57775fc7",
     "grade": true,
     "grade_id": "cell-f0437392a07c97b0",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# On teste la fonction \n",
    "assert coefbinom(2,4) == 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "23bee2da1cae5ee6d8af598ce2069a97",
     "grade": false,
     "grade_id": "cell-3332b552e3081b10",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Vous voyez que des fonctions peuvent s'appeler entre elles. Le code est ainsi plus concis et plus limpide. On évite les répétitions et on limite les erreurs.\n",
    "\n",
    "Il est donc **fortement** conseillé de les utiliser le plus possible dans vos programmes et votre projet.\n",
    "\n",
    "D'une manière générale, quand vous allez chercher à écrire un programme pour réaliser une tache, **avant d'écrire la moindre ligne de code**, vous allez réfléchir au découpage de votre tache en sous taches qui seront éxécutées chacune par une ou plusieurs fonctions. Une fois la spécification précise de ces fonctions réalisées, alors vous pourrez commencer à écrire ces fonctions, puis votre programme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ca37b49a443eac24bc5ff8a5842a0ef8",
     "grade": false,
     "grade_id": "cell-7c5a5744fe6b1f44",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Boucle Tant que"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "94f20f21a73e276b0dd432e58a48fd19",
     "grade": false,
     "grade_id": "cell-c2d52dcc4a3f6cc6",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Exécuter la fonction exemple ci-dessous. Quel est son rôle ?\n",
    "Remarquez la présence des `:` et le décalage de marge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "399f1ff95636ea879830c7b19d4aeb67",
     "grade": false,
     "grade_id": "cell-e92a367c94a34f69",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "def exemple():\n",
    "    u=10\n",
    "    n=0\n",
    "    while u<20:\n",
    "        u = u+1.1\n",
    "        n = n+1\n",
    "    return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invoquez la fonction exemple ci-dessous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b1871ea548cf55398d3c3de7ae2cf177",
     "grade": false,
     "grade_id": "cell-cac0858d873472a5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## A vous de jouer ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ef84394607881e6a9e4ddf3834877747",
     "grade": false,
     "grade_id": "cell-3eb2231d953ecd59",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Soit $(u_n)_{n\\in\\mathbb N}$ la suite définie par\n",
    "- $u_0=2$\n",
    "- $u_{n+1}=0,2\\times u_n+10$\n",
    "\n",
    "Déterminer le plus petit rang $n$ pour lequel $u_n\\geqslant 12.49995$\n",
    "\n",
    "Pour cela, complétez la fonction seuil ci-dessous \n",
    "- prenant en paramètre une variable $s$ contenant le seuil à dépasser\n",
    "- renvoyant le rang $n$ à partir duquel le seuil $s$ est dépassé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "a99105e411021a950a8d333fcce5f8ba",
     "grade": false,
     "grade_id": "cell-02c776321d4afb68",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def seuil(s):\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e21e91ceb460eabd1301606e1c3af1d9",
     "grade": false,
     "grade_id": "cell-650cf29dc6a0a2e5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "La cellule suivante doit s'exécuter sans erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "a145164e642abe00b7810cabf9ba6436",
     "grade": true,
     "grade_id": "cell-ce9f6a32ddfe534b",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert seuil (12.49995) == 8"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}