TP_suites_enonce.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP :  Étude de suites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Ce TP est dédié à l'étude qualitative de suites numériques. Il comprend une part assez faible de programmation, et une part plus importante d'expérimentation et d'interprétation mathématique des résultats observés.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Préliminaire** Importer les modules `numpy` et `matplotlib.pyplot`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I. Étude d'une suite simple\n",
    "\n",
    "On étudie la suite définie par\n",
    "$$ \n",
    "u_n = \\left( 1+\\frac{1}{n}\\right) ^n \\qquad n>0\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Écrire une fonction `u(n)` prenant en argument un entier $n$ et rendant $_n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Faire représenter par un nuage de points les 30 premières valeurs de la suite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il semble d'après ce dessin que la suite $(u_n)$ converge vers une valeur proche de 2,7.\n",
    "\n",
    "Un calcul de développement limité, que vous devez savoir faire (cours de L1 !), montre que $\\lim_{n\\to\\infty} u_n = e$.\n",
    "\n",
    "On va donc essayer de mettre en évidence cette convergence ainsi que la vitesse de convergence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Importer la constante `e` du module `math`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Faire afficher $|u_n - e|$ en fonction de $n$, pour $n\\in[1,30]$, en choisissant la représentation la plus appropriée pour caractériser la vitesse de convergence (penser à utiliser des représentations logarithmiques)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice**\n",
    "\n",
    "On peut montrer mathématiquement en faisant un développement limité que \n",
    "$$\n",
    "u_n = e -\\frac{a}{n} + o\\left(\\frac{1}{n}\\right)\n",
    "$$\n",
    "avec  $a = \\frac{e}{2}$.\n",
    "Mettez ceci en évidence grâce à une représentation graphique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II. Outils pour l'étude des suites récurrentes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On étudie ici une suite numérique $(u_n)$ définie par récurrence par la relation $u_{n+1}=f(u_n)$ et la donnée de de \n",
    "la valeur initiale $u_0$.\n",
    "\n",
    "**Exercice** Ecrire une fonction `valeurs_suite(a,f,N,p)` prenant en arguments :\n",
    "- la valeur initiale `a`\n",
    "- la fonction de récursion `f`\n",
    "- le nombre de points affichés `N`\n",
    "- le premier indice affiché `p`  (par défaut 0).\n",
    "et affichant un nuage de `N` points de la suite en commençant par la valeur $u_p$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemple d'utilisation : la commande suivante affichera 100 points de la suite, définie par la fonction de récursion $f:x\\mapsto 3.5 x(1-x)$ et la valeur initiale $u_0 = 0.3$, à partir de la valeur $u_{5000}$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 3.55 * x * (1-x)\n",
    "valeurs_suite(0.3,f,100,5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Représentation en escalier** \n",
    "\n",
    "**Exercice** Ecrire une fonction `escalier(m,M,f,a,N)`  qui représente sur un même diagramme le graphe de `f`, la première diagonale, et l'escalier reliant les points $(u_0,u_1)$, $(u_1,u_1)$, $(u_1,u_2)$, $u_2,u_2)$, ..., $(u_N,u_N)$, $(u_n,u_{n+1})$.\n",
    "\n",
    "Arguments d'entrée :\n",
    "- les limites `m` et `M` de l'intervalle d'étude\n",
    "- la fonction de récursion `f`\n",
    "- la valeur initiale de la suite `a`\n",
    "- le nombre de valeurs calculées pour la suite `N`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution  des deux questions précédentes\n",
    "\n",
    "Comme les expérimentations qui suivent s'appuient sur l'utilisation des deux fonctions `valeurs_suite(a,f,N,p)` et `escalier(m,M,f,a,N)`, voilà une écriture possible de ces fonctions, qui vous permettra de mener à bien la suite de l'étude. Si vous avez écrit correctement vos propres fonctions, vous êtes invités à les utiliser à la place de celles que nous vous proposons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def valeurs_suite(a,f,N,p=0):\n",
    "    u = a\n",
    "    for i in range(p):\n",
    "        u = f(u)\n",
    "    U = []\n",
    "    for i in range(N):\n",
    "        U.append(u)\n",
    "        u = f(u)\n",
    "    plt.scatter(range(p,p+N),U)\n",
    "\n",
    "def escalier(m,M,f,a,N):\n",
    "    x = np.linspace(m,M,1000)\n",
    "    y = f(x)\n",
    "    u = a\n",
    "    X = [a]\n",
    "    Y = []\n",
    "    for i in range(N):\n",
    "        u = f(u)\n",
    "        X.extend([u,u])\n",
    "        Y.extend([u,u])\n",
    "    Y.append(f(u))\n",
    "    plt.plot(X,Y)\n",
    "    plt.plot(x,y,label=\"y=f(x)\")\n",
    "    plt.plot(x,x,label=\"y=x\")\n",
    "    plt.legend()\n",
    "    plt.title(\"Tracé d'un escalier\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III. Etude de la suite logistique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va étudier des suites récurrentes définies par\n",
    "$$\n",
    "u_0 = a \\in [0,1]\n",
    "$$\n",
    "$$\n",
    "u_{n+1} = c u_n (1-u_n)\n",
    "$$\n",
    "Une telle suite est appelée \"suite logistique\". Ces suites sont associées à la modélisation de l'évolution d'une population animale dans un environnement limité."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On commence par étudier les fonctions de récursion :\n",
    "$$\n",
    "f_c (x) = cx(1-x)\n",
    "$$\n",
    "\n",
    "**Exercice** Ecrire une fonction `f(c,x)` prenant en argument les réels $c$ et $x$, et rendant $f_c(x)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(c,x):\n",
    "    return c * x * (1-x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice**   Faire tracer sur un même diagramme les graphes de $f_c$ sur l'intervalle $[0,1]$ pour différentes valeurs de $c$ comprises entre 0 et 4, ainsi que la première diagonale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On constatera que l'intervalle $I=[0,1]$ vérifie $f_c(I)\\subset I$, à condition que $c$ soit compris entre $0$ et $4$.  Dans la suite de l'étude, on prendra donc $c\\in[0,4]$.\n",
    "\n",
    "On constate par ailleurs que le graphe de $f_c$ est en dessous de la première diagonale pour $c\\leq 1$. \n",
    "\n",
    "Pour $c>1$, le graphe de $f_c$ coupe la première diagonale en un réel $l_c\\in]0,1[$.\n",
    "\n",
    "Le nombre $l$ vérifie $f_c'(l_c) \\geq 0$ si $c\\leq 2$ et $f_c'(l_c) \\leq 0$ si $c\\geq 2$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans toute la suite, on va afficher les suites $(u_n)$ de différentes façons, et regarder leur comportement en fonction de $c$. On choisira une valeur initiale de manière arbitraire.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $c<1$\n",
    "\n",
    "**Exercice** Prenons $c=\\frac{1}{2}$ et considérons la fonction  $f:x\\mapsto \\frac{1}{2}x(1-x)$.\n",
    "- Définir `f`\n",
    "- Faire afficher les valeurs de la suite\n",
    "- Faire afficher le diagramme en escalier associé\n",
    "A partir de ces observations, vous verrez que la suite $(u_n)$ converge vers 0 en décroissant.\n",
    "- Caractériser sa vitesse de convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 0.5*x*(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $c=1$.\n",
    "\n",
    "**Exercice** Même étude lorsque $c=1$.\n",
    "On constatera un comportement globalement équivalent au précédent, mais la vitesse de convergence n'est pas la même. Essayez de bien mettre en évidence cette différence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: x*(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $1<c<2$.\n",
    "\n",
    "**Exercice** Prenons  $f : x\\mapsto \\frac{3}{2} x(1-x)$\n",
    "- Définir la fonction `f`\n",
    "- Tracer un nuage de points et un diagramme en escalier étudiant le comportement de la suite $(u_n)$.\n",
    "Vous constaterez que la suite converge en croissant vers une limite $l\\neq 0$.\n",
    "- Déterminer mathématiquement la valeur de $l$\n",
    "- Caractériser la vitesse de convergence de la suite vers $l$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 1.5 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $c=2$\n",
    "\n",
    "**Exercice** Mener une étude analogue avec  $f:2x\\mapsto x(1-x)$. On verra que le comportement est globalement identique, mais que la vitesse de convergence est différente. Essayez de caractériser cette vitesse de convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 2 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $2<c<3$.\n",
    "\n",
    "**Exercice** Prenons par exemple $f:x\\mapsto \\frac{5}{2} x (1-x)$. quel changement observe-t-on par rapport aux cas précédents. Expliquez d'où cela vient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 2.5 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le cas $c=3$\n",
    "\n",
    "**Exercice** Considérons la fonction $f: x \\mapsto 3x(1-x)$.\n",
    "- Mener une étude analogue au cas précédent\n",
    "- On constatera une convergence vers une limite $l$ que l'on précisera, mais on verra que cette convergence est très lente. Mettre ce phénomène en évidence graphiquement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 3 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Et pour $c>3$ ?\n",
    "\n",
    "On a vu que la suite avait déjà du mal à converger lorsque $c=3$. On peut imaginer qu'elle ne va plus converger pour $c>3$. C'est effectivement ce qui va se passer, mais cela demande à être étudié de près."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Prenons d'abord $c=3.2$ et $f: x \\mapsto 3.2 \\, x(1-x)$.\n",
    "- Mettre en évidence que la suite a alors deux valeurs d'adhérence. Plus précisément, chacune des deux sous-suites $v_k=u_{2k}$ et $w_k=u_{2k+1}$ converge, de façon monotone, mais leurs limites ne sont pas égales.\n",
    "- Il pourra être intéressant de travailler avec la fonction $g=f\\circ f$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 3.2 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice**  Mener une étude analogue avec  $f:x \\mapsto 3.5\\, x(1-x)$. \n",
    "\n",
    "Dans ce cas, il pourra être intéressant de regarder séparément les comportements des suites extraites  $(u_{4n})$, $(u_{4n+1})$, $(u_{4n+2})$, $(u_{4n+3})$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 3.5 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Même chose avec $f:x\\mapsto 3.55\\, x(1-x)$. Combien de valeurs d'adhérence observe-t-on ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 3.55 * x * (1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encore plus compliqué\n",
    "Plus $c$ se rapproche de 4, plus la situation semble compliquée. Testez par exemple $c=3.85$, $c=3.95$ et $c=4$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Dans le cas $c=4$, vous avez constaté  que la suite occupe uniformément l'intervalle $[0,4]$. Pour mieux le mettre en évidence, faites calculer les 100000 premiers termes de la suite, et faites tracer leur histogramme de répartition en 100 classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On constatera une répartition presque uniforme au centre de l'intervalle, avec cependant une accumulation sur les bords."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Évolution des valeurs d'adhérence suivant les valeurs de $c$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une façon de mettre en évidence les valeurs d'adhérence est de regarder les valeurs de $u_n$ pour $n\\in [N_1,N_2]$, où $N_1$ et $N_2$ sont des nombres suffisamment grands. \n",
    "\n",
    "**Exercice** Écrire une fonction `valeurs_adherence(c)` qui prend en argument un réel $c$, calcule les valeurs de $u_n$, pour $n$ compris entre $N_1 = 100000$ et $N_2 = 200000$ et trace l'histogramme de répartition de ces valeurs  en 300 classes.\n",
    "On regadera ensuite la répartition des $u_n$ en faisant tracer un histogramme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def valeurs_adherence(c):\n",
    "    f = lambda x: c * x*(1-x)\n",
    "    # A compléter...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez alors pour différentes valeurs de $c$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.55)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.56)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.565)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeurs_adherence(3.57)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diagramme de Feigenbaum\n",
    "\n",
    "Pour avoir une vision graphique de la façon dont évaluent les valeurs d'adhérence lorsque $c$ varie, on va faire varier $c$ entre deux bornes $c_1$ et $c_2$, et pour chcune des valeurs de $c$, on va tracer les points $(c,u_n)$ pour $n$ variant entre deux valeurs $N$ et $N+p$, en prenant par exemple $N=1000$ et $p=200$.\n",
    "\n",
    "Je vous donne ici une fonction qui réalise ce programme. Je vous demande juste de comprendre ce qu'elle fait, de la tester pour différentes zones $[c_1,c_2]$, et de voir comment les observations ainsi faites explicitent ce que vous avez vu précédemment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feigenbaum(u0,c1,c2):\n",
    "    x=[]\n",
    "    y=[]\n",
    "    N = 1000\n",
    "    p = 200\n",
    "    x = []  # le vecteur des abscisses\n",
    "    y = []  # le vecteur des ordonnées\n",
    "    for c in np.linspace(c1,c2,500):\n",
    "        x += p*[c] # on va tracer p points d'abscisse p\n",
    "        u = u0\n",
    "        for i in range(N):\n",
    "            u = c*u*(1-u)\n",
    "        for i in range(p):\n",
    "            u = c*u*(1-u)\n",
    "            y.append(u)  # on met les ordonnées des p points au dessus de c\n",
    "    plt.scatter(x,y,s=1)  # et on affiche les points, en choisissant une petite taille de points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice de conclusion** Pour terminer ce TP, faites un résumé de ce que vous avez observé."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}