Escargots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La diversité génétique au cours du temps\n",
    "\n",
    "Nous avons, en cours de biologie, mis en évidence la problématique de la dérive génétique. Nous avons simulé\n",
    "avec des billes l’histoire d’escargots vivant dans un îlot. Cette expérience est longue à faire. Grâce à notre dernier\n",
    "module de mathématiques, nous pouvons maintenant faire la simulation sur ordinateur.\n",
    "\n",
    "Au fur et à mesure de cet exercice, compléter le compte rendu de TP.\n",
    "\n",
    "## Initialisation de Python\n",
    "\n",
    "Nous importons les bibliothèques de fonctions utiles au TP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traduction des actions du TP de Biologie en Python\n",
    "\n",
    "Nous avions en main le matériel suivant.\n",
    "\n",
    "<IMG SRC=\"algoescargot0.png\">\n",
    "\n",
    "### Simulation d'un dé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dé = [1,2,3,4,5,6]\n",
    "print(dé)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, les crochets signifient que l’on crée une liste. Par exemple, la variable `dé` est une liste de 6 entiers de\n",
    "1 à 6 qui modélise les 6 faces du dé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "face = random.choice(dé)\n",
    "print(face)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 1 du compte-rendu\n",
    "\n",
    "Exécuter plusieurs fois le code ci-dessus. Obtient-on toujours le même résultat ? Que signifie random et choice en anglais ?\n",
    "En déduire ce que fait la fonction random.choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation de la reproduction des escargots\n",
    "\n",
    "Nous allons reprendre les couleurs des billes du TP de Biologie. À savoir : `['Blanc','Bleu','Rouge','Jaune','Vert','Noir']`.\n",
    "\n",
    "Exécuter plusieurs fois la commande suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(['Bleu']*random.choice(dé))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette commande `['Bleu']*random.choice(dé)` permet de construire une liste `[]` contenant autant de fois le mot `'Bleu'` que le résultat de `random.choice(dé)`. Elle simule donc la reproduction de l'escargot bleu et nous donne la liste des petits.\n",
    "\n",
    "### Question 2 du compte-rendu\n",
    "\n",
    "Quelle instruction Python permet d'afficher la liste des petits de l'escargot rouge ?\n",
    "Essayez votre solution dans le cadre ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Faire vos essais dans ce cadre\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation du sac\n",
    "\n",
    "Créons un sac vide puis remplissons le avec les petits de nos escargots. Exécuter les codes suivants dans l'ordre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = []\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = sac + ['Blanc']*random.choice(dé)\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = sac + ['Bleu']*random.choice(dé)\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = sac + ['Rouge']*random.choice(dé)\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = sac + ['Jaune']*random.choice(dé)\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sac = sac + ['Vert']*random.choice(dé)\n",
    "print(sac)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 3 du compte-rendu\n",
    "\n",
    "En étudiant les codes et les résultats des lignes de codes précédentes, expliquer ce qui se passe lorsque l'on ajoute deux listes. Expliquer ce que fait l'instruction `sac = sac + ['Vert']*random.choice(dé)` dans le cadre de notre TP. En déduire l'instruction permettant de compléter le sac avec les petits de l'escargot noir. Essayez votre code dans le cadre de code suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Faire vos essais dans ce cadre\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation des escargots survivants dans l'îlot.\n",
    "\n",
    "Exécuter le code suivant plusieurs fois."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = random.sample(sac,6) ; print(ilot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 4 du compte-rendu\n",
    "\n",
    "Que signifie sample en anglais ? Expliquer alors l'instruction `random.sample(sac,6)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traduction de l'algorithme du TP de Biologie en Python\n",
    "\n",
    "Voici l'algorithme que nous avons utilisé en TP de Biologie.\n",
    "\n",
    "\n",
    "<IMG SRC=\"algoescargot.png\">\n",
    "\n",
    "### Accès aux escargots de l'îlot\n",
    "\n",
    "En python, on peut accéder aux éléments d'une liste en écrivant le nom de la liste suivie du numéro de l'élément qui nous intéresse entre crochets.\n",
    "\n",
    "Exécuter le code suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "print(ilot)\n",
    "print(ilot[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 5 du compte-rendu\n",
    "\n",
    "L'instruction `print(ilot[2])` a-t-elle permis d'accéder au deuxième élément de l'ilot ? Comment faire alors pour accéder au deuxième élément de l'ilot ? Comment faire alors pour accéder au premier élément de l'ilot ? Essayez votre solution dans le cadre ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# faire vos essais dans ce cadre\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quand arrêter la simulation ?\n",
    "\n",
    "Les escargots se reproduiront toujours. Mais dans notre simulation, nous nous sommes arrêtés lorsque tous les escargots de l'îlot étaient de la même couleur. En effet, inutile de continuer dans ce cas puisque la simulation ne peut que revenir à la même situation.\n",
    "\n",
    "Nous devons demander à Python de travailler *Tant que* l'un des escargots est différent des autres.\n",
    "\n",
    "Autrement dit : *Tant que* le premier escargot est différent de l'un des autres, Python doit continuer la simulation.\n",
    "\n",
    "Dit de manière encore plus explicite : *Tant que* le premier escargot est différent du deuxième ou du troisième ou ... ou du dernier, Python doit continuer la simulation.\n",
    "\n",
    "Voici comment l'écrire en Python. Exécuter les cadres de codes suivants en observant le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Blanc','Rouge','Jaune','Vert','Noir']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Blanc','Blanc','Jaune','Vert','Noir']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Blanc','Blanc','Blanc','Vert','Noir']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Blanc','Blanc','Blanc','Blanc','Noir']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ilot = ['Blanc','Blanc','Blanc','Blanc','Blanc','Blanc']\n",
    "ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 6 du compte-rendu\n",
    "\n",
    "Que signifie True et False en anglais ?\n",
    "\n",
    "Quand l'instruction `ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]` donne-t-elle False ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programme Python simulant le TP de biologie\n",
    "\n",
    "Voici maintenant comment traduire notre algorithme.\n",
    "\n",
    "<IMG SRC=\"algoescargot1.png\">\n",
    "    \n",
    "Autrement dit :\n",
    "\n",
    "<IMG SRC=\"algoescargot2.png\">\n",
    "    \n",
    "Et en Python :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "dé = [1,2,3,4,5,6]\n",
    "ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "\n",
    "# tant qu’il y a plusieurs allèles\n",
    "\n",
    "while (ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]):\n",
    "    # les 6 escargots se reproduisent\n",
    "    sac=[ilot[0]]*random.choice(dé)+[ilot[1]]*random.choice(dé)+[ilot[2]]*random.choice(dé)+[ilot[3]]*random.choice(dé)+[ilot[4]]*random.choice(dé)+[ilot[5]]*random.choice(dé)\n",
    "    # On garde 6 escargot pris au hasard\n",
    "    ilot=random.sample(sac,6)\n",
    "    # on écrit le résultat\n",
    "    print(ilot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 7 du compte-rendu\n",
    "\n",
    "Exécuter plusieurs fois le cadre de code précédent. Observer le résultat. Quelle est la longueur de l’histoire la plus courte ? la plus longue ? Les 6 couleurs finales possibles sont-elles\n",
    "« équifréquentes » ? Est-ce facile de répondre à ces questions ?\n",
    "\n",
    "## Optimisation du programme pour obtenir rapidement davantage de résultats\n",
    "\n",
    "L'histoire complète des escargots ne nous intéresse pas. Seuls le nombre de générations et la couleur « finale » nous intéresse.\n",
    "\n",
    "Nous allons retirer l'affichage de l'ilot et le remplacer par l'utilisation d'un compteur.\n",
    "\n",
    "### Questions 8 du compte-rendu\n",
    "\n",
    "Compléter le code suivant, c'est à dire compléter les deux lignes commençant par `CompteurGénération =` et permettant de compter le nombre de tours de boucle. Recopier ces deux lignes seulement sur le compte-rendu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "dé = [1,2,3,4,5,6]\n",
    "ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "\n",
    "# initialisation du compteur\n",
    "CompteurGénération = \n",
    "\n",
    "# tant qu’il y a plusieurs allèles\n",
    "\n",
    "while (ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]):\n",
    "    # les 6 escargots se reproduisent\n",
    "    sac=[ilot[0]]*random.choice(dé)+[ilot[1]]*random.choice(dé)+[ilot[2]]*random.choice(dé)+[ilot[3]]*random.choice(dé)+[ilot[4]]*random.choice(dé)+[ilot[5]]*random.choice(dé)\n",
    "    # On garde 6 escargot pris au hasard\n",
    "    ilot=random.sample(sac,6)\n",
    "    # on compte ce tour (au suivant !)\n",
    "    CompteurGénération = \n",
    "\n",
    "print(\"il reste l’escargot\",ilot[0],\"en\",CompteurGénération,\"générations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 9 du compte-rendu\n",
    "\n",
    "Exécuter plusieurs fois le cadre de code précédent. Observer le résultat. Quelle est la longueur de l’histoire la plus courte ? la plus longue ? Les 6 couleurs finales possibles sont-elles\n",
    "« équifréquentes » ? Est-ce plus facile de répondre à ces questions ?\n",
    "\n",
    "Rendez le compte-rendu au professeur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encore plus vite !\n",
    "\n",
    "Pour la suite du TP, compléter la feuille distribuée pour le deuxième compte-rendu.\n",
    "\n",
    "### Avant de commencer\n",
    "\n",
    "Exécuter le code suivant. Ne pas chercher à le comprendre. Ce code permettra de tracer un diagramme en bâtons dans le programme final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as repere\n",
    "import numpy as np\n",
    "\n",
    "# la suite de ce programme n'est pas étudiée ici. Elle sert à afficher les résultats\n",
    "def compte(liste):\n",
    "    liste=sorted(liste)                         #On trie la liste pour rencontrer les éléments par ordre croissant.\n",
    "    listf=[liste[0]]                            #Initialise la liste des valeurs avec la première valeur\n",
    "    eff=[liste.count(liste[0])]                 #Initialise la liste des effectifs avec le premier effectif associé\n",
    "    for i in range(len(liste)):                 #On parcourt la série\n",
    "        if liste[i] not in listf:\n",
    "            listf.append(liste[i])              #Si l'élément n'a pas encore été rencontré, il est ajouté à la liste.\n",
    "            eff.append(liste.count(liste[i]))   #Ajoute à la liste des effectifs, l'effectif associé à cette nouvelle valeur\n",
    "    return sorted(listf),eff\n",
    "\n",
    "def Graphique(MaListe):\n",
    "    nom,eff=compte(MaListe)   # cette commande crée un tableau de valeurs agrégées\n",
    "    x=np.arange(len(nom))     # ces dernières commandes permettent de\n",
    "    repere.bar(x,eff)         # tracer le graphique en bâtons\n",
    "    repere.xticks(x,nom)      # correspondant\n",
    "    repere.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Répéter la simulation un grand nombre de fois\n",
    "\n",
    "Avec une boucle *pour*, nous allons répéter notre simulation et à chaque fois nous allons conserver les résultats (nombre de générations et couleur finale) dans deux listes.\n",
    "\n",
    "### Questions 1 du compte-rendu\n",
    "\n",
    "Que signifie append en anglais ?\n",
    "\n",
    "Citez les lignes où on initialise les deux listes pour conserver le nombre de générations et la couleur finale.\n",
    "\n",
    "Citez les lignes où on ajoute les résultats de la nouvelle simulation aux listes.\n",
    "\n",
    "Que signifie mean en anglais ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import matplotlib.pyplot as repere\n",
    "import numpy as np\n",
    "\n",
    "de = [1,2,3,4,5,6]\n",
    "ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "\n",
    "nbSimul=int(input(\"Entrez le nombre de simulations à faire : \"))\n",
    "ListeGénération=[]\n",
    "ListeCouleur=[]\n",
    "compteurGénération = 0      # compteur du nombre de cycles ou générations\n",
    "\n",
    "for compteurSimul in range(nbSimul):\n",
    "    ilot = ['Blanc','Bleu','Rouge','Jaune','Vert','Noir']\n",
    "    compteurGénération = 0\n",
    "    # tant qu'il y a plusieurs allèles\n",
    "    while (ilot[0]!=ilot[1] or ilot[0]!=ilot[2] or ilot[0]!=ilot[3] or ilot[0]!=ilot[4] or ilot[0]!=ilot[5]):\n",
    "        sac = [ilot[0]]*random.choice(de)+ [ilot[1]]*random.choice(de)+ [ilot[2]]*random.choice(de)+  [ilot[3]]*random.choice(de)+[ilot[4]]*random.choice(de)+[ilot[5]]*random.choice(de) # les 6 escargots se reproduisent\n",
    "        ilot = random.sample(sac,6)                     # On garde 6 escargot pris au hasard\n",
    "        compteurGénération = compteurGénération + 1     # on compte ce tour (au suivant !)\n",
    "    ListeGénération.append(compteurGénération)          # conserve le nombre de cycles\n",
    "    ListeCouleur.append(ilot[0])                        # conserve la couleur finale\n",
    "\n",
    "Graphique(ListeCouleur)\n",
    "\n",
    "print(\"le cycle le plus court est :\",min(ListeGénération))\n",
    "print(\"le cycle le plus long est :\",max(ListeGénération))\n",
    "print(\"la moyenne est :\",np.mean(ListeGénération))\n",
    "\n",
    "Graphique(ListeGénération)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Questions 2 du compte-rendu\n",
    "\n",
    "Exécuter le programme précédent pour 100 simulations. Recopier le premier graphique et les valeurs dans la première colonne du polycopié de compte-rendu.\n",
    "\n",
    "\n",
    "### Questions 3 du compte-rendu\n",
    "\n",
    "Exécuter le programme précédent pour 1000 simulations. Recopier le premier graphique et les valeurs dans la deuxième colonne du polycopié de compte-rendu.\n",
    "\n",
    "### Questions 4 du compte-rendu\n",
    "\n",
    "Exécuter le programme précédent pour 10 000 simulations. Recopier le premier graphique et les valeurs dans la troisième colonne du polycopié de compte-rendu.\n",
    "\n",
    "Attention, avec 100 000 simulations, il faudra attendre plus d'une minute.\n",
    "\n",
    "### Questions 5 du compte-rendu\n",
    "\n",
    "Répondons maintenant aux biologistes.\n",
    "\n",
    "Dans une petite population non soumise à la prédation, On assiste à une dérive génétique.\n",
    "\n",
    "Les allèles « restants » sont-ils « équifréquents » ? Pourquoi ?\n",
    "\n",
    "Est-il possible que la diversité génétique résiste à la dérive ?"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}