PILE-FACE-Fréquences.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ALGORITHME et PROBABILITES\n",
    "\n",
    "   * Les algorithmes seront écris en [python ](https://www.youtube.com/watch?v=74Im6zOHeow).\n",
    "\n",
    "   * Le code est exécuté dans une cellule de ... *code*:\n",
    "       * en cliquant sur le triangle *Run the selected cell*\n",
    "       * depuis le clavier, si la cellule est sélectionnée, par **SHIFT+ENTREE**\n",
    "   * Essayez avec la cellule ci-dessous. Le texte en anglais est un ensemble de conseils pour écrire du code pythonien. On peut le traduire [ici](https://www.deepl.com/translator#en/fr/The%20Zen%20of%20Python%2C%20by%20Tim%20Peters%0A%0ABeautiful%20is%20better%20than%20ugly.%0AExplicit%20is%20better%20than%20implicit.%0ASimple%20is%20better%20than%20complex.%0AComplex%20is%20better%20than%20complicated.%0AFlat%20is%20better%20than%20nested.%0ASparse%20is%20better%20than%20dense.%0AReadability%20counts.%0ASpecial%20cases%20aren't%20special%20enough%20to%20break%20the%20rules.%0AAlthough%20practicality%20beats%20purity.%0AErrors%20should%20never%20pass%20silently.%0AUnless%20explicitly%20silenced.%0AIn%20the%20face%20of%20ambiguity%2C%20refuse%20the%20temptation%20to%20guess.%0AThere%20should%20be%20one--%20and%20preferably%20only%20one%20--obvious%20way%20to%20do%20it.%0AAlthough%20that%20way%20may%20not%20be%20obvious%20at%20first%20unless%20you're%20Dutch.%0ANow%20is%20better%20than%20never.%0AAlthough%20never%20is%20often%20better%20than%20*right*%20now.%0AIf%20the%20implementation%20is%20hard%20to%20explain%2C%20it's%20a%20bad%20idea.%0AIf%20the%20implementation%20is%20easy%20to%20explain%2C%20it%20may%20be%20a%20good%20idea.%0ANamespaces%20are%20one%20honking%20great%20idea%20--%20let's%20do%20more%20of%20those!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Commençons en important trois modules\n",
    "Nous avons besoin de quelques super pouvoirs alors *importons* quelques objets dans les *modules* **random** et **collections**.\n",
    "On s'y prend de la fçon suivante:\n",
    "\n",
    "```python\n",
    "    from LeModuleQuiMinterresse import leTrucDontJaiBesoin\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import choice, choices\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# On simule le lancé d'un seul dé à 12 faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Executer plusieurs fois cette cellule pour voir commen choice() fonctionne:\n",
    "faces_dé = [1,2,3,4,5,6,7,8,9,10,11,12]\n",
    "choice(faces_dé)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# On simule 100 lancés PILE ou FACE et on compte les *issues* (les résultats observés):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'P': 485, 'F': 515})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N_Lancers = 1000\n",
    "faces_pièce = ['P','F']\n",
    "Lancers = choices(faces_pièce, k = N_Lancers)\n",
    "Counter(Lancers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculons la fréquence d'obtention du côté PILE:\n",
    "\n",
    "\n",
    "```python\n",
    "    résultats_des_lancés\n",
    "```\n",
    "\n",
    "Est un dictionnaire, ce qui va nous permettre de recupérer le nombre de PILE **P** et de calculer la fréquence des côtés PILE:\n",
    "\n",
    "$$\\large{f_{_P} = \\dfrac{N_P}{N_{lances}}}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "résultats_des_lancés = Counter(Lancés)\n",
    "N_P = résultats_des_lancés['P']\n",
    "f_P =  N_P / N_Lancés\n",
    "print('La fréquence des côté PILE est:',f_P,' pour ', N_Lancés,' lancés.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comment répéter ces 100 lancés?\n",
    "On va utiliser une boucle \n",
    "\n",
    "```python\n",
    "   for variable in range(VALEUR_MAX):\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Série: 0  . La fréquence des côté PILE est: 0.496  pour  5000  lancés.\n",
      "Série: 1  . La fréquence des côté PILE est: 0.5114  pour  5000  lancés.\n",
      "Série: 2  . La fréquence des côté PILE est: 0.5042  pour  5000  lancés.\n",
      "Série: 3  . La fréquence des côté PILE est: 0.5102  pour  5000  lancés.\n",
      "Série: 4  . La fréquence des côté PILE est: 0.492  pour  5000  lancés.\n",
      "Série: 5  . La fréquence des côté PILE est: 0.4914  pour  5000  lancés.\n",
      "Série: 6  . La fréquence des côté PILE est: 0.5044  pour  5000  lancés.\n",
      "Série: 7  . La fréquence des côté PILE est: 0.4894  pour  5000  lancés.\n",
      "Série: 8  . La fréquence des côté PILE est: 0.4912  pour  5000  lancés.\n",
      "Série: 9  . La fréquence des côté PILE est: 0.4896  pour  5000  lancés.\n",
      "Série: 10  . La fréquence des côté PILE est: 0.4942  pour  5000  lancés.\n",
      "Série: 11  . La fréquence des côté PILE est: 0.5138  pour  5000  lancés.\n",
      "Série: 12  . La fréquence des côté PILE est: 0.5128  pour  5000  lancés.\n",
      "Série: 13  . La fréquence des côté PILE est: 0.522  pour  5000  lancés.\n",
      "Série: 14  . La fréquence des côté PILE est: 0.499  pour  5000  lancés.\n",
      "Série: 15  . La fréquence des côté PILE est: 0.5062  pour  5000  lancés.\n",
      "Série: 16  . La fréquence des côté PILE est: 0.4974  pour  5000  lancés.\n",
      "Série: 17  . La fréquence des côté PILE est: 0.502  pour  5000  lancés.\n",
      "Série: 18  . La fréquence des côté PILE est: 0.4976  pour  5000  lancés.\n",
      "Série: 19  . La fréquence des côté PILE est: 0.5122  pour  5000  lancés.\n"
     ]
    }
   ],
   "source": [
    "N_répétitions = 20\n",
    "N_Lancés =5000\n",
    "for lancé in range(N_répétitions):\n",
    "    Lancés = choices(['P','F'], k = N_Lancés)\n",
    "    résultats_des_lancés = Counter(Lancés)\n",
    "    N_P = résultats_des_lancés['P']\n",
    "    f_P =  N_P / N_Lancés\n",
    "    print('Série:',lancé,' . La fréquence des côté PILE est:',f_P,' pour ', N_Lancés,' lancés.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copier-Coller le code ci-dessus dans la cellule ci-dessous:\n",
    "\n",
    "   * Modifier le code pour réaliser des séries de 10 lancés, puis de 50 lancés et de 1000 lancés.\n",
    "   * Que remarque-t-on pour les fréquences d'obtention du côté **PILE**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Copier coller sous cette ligne\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simplification du code:\n",
    "\n",
    "Le code ci-dessous simule des séries de lancés de dés,\n",
    "\n",
    "```python\n",
    "    for lancé in range(N_répétitions):\n",
    "        Lancés = choices(['P','F'], k = N_Lancés)\n",
    "        résultats_des_lancés = Counter(Lancés)\n",
    "        N_P = résultats_des_lancés['P']\n",
    "        f_P =  N_P / N_Lancés\n",
    "\n",
    "```\n",
    "On va l'encapsuler dans une fonction. Il faudra lui donner:\n",
    "\n",
    "   * le nombre de série à réaliser\n",
    "   * le nombre de répétitions de chaque série\n",
    "\n",
    "### C'est quoi une fonction en python?\n",
    "\n",
    "   * Des explications concernant le nom de la fonction ci-dessous: https://vimeo.com/59258528"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ma première fonction\n",
    "def boite_à_coucou():\n",
    "    print('Coucou !')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boite_à_coucou()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#une deuxième fonction avec un argument: c'est à dire un objet que la fonction va utiliser pour faire quelque chose\n",
    "def boite_à_coucou(ordre = \"Dit coucou\"):\n",
    "    print(ordre + ': Coucou !')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boite_à_coucou()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boite_à_coucou(\"Ne dit pas coucou!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boite_à_coucou(ordre = \" Johny a dit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fonction simulant une série de lancés:\n",
    "\n",
    "   * Il y aura $ s $ séries de lancés\n",
    "   * Dans chaque série, la fonction simulera $l$ lancés.\n",
    "   * La fonction aura donc deux arguments dont on pourra fixé une valeur par defaut\n",
    "   \n",
    "```python \n",
    "        def simulation_séries_de_lancés(s = 20, l = 100):\n",
    "```\n",
    "Ces deux arguments demandent la simulation de 20 séries de 100 lancés à **PILE** ou **FACE**   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulation_séries_de_lancés(N_séries = 20, N_lancers = 100):\n",
    "    fréquence_P_séries = {}\n",
    "    for s in range(N_séries):\n",
    "        Lancers = choices(['P','F'], k = N_lancers)\n",
    "        résultats_des_lancers = Counter(Lancers)\n",
    "        N_P = résultats_des_lancers['P']\n",
    "        f_P =  N_P / N_lancers\n",
    "        fréquence_P_séries[s] = f_P\n",
    "    return fréquence_P_séries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fréquences_P = simulation_séries_de_lancés(N_séries = 20, N_lancers = 5000)\n",
    "print(fréquences_P)\n",
    "for f in fréquences_P.values():\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for série, f in zip(fréquences_P.keys(), fréquences_P.values()):\n",
    "    print(\"série:\", série, \"  fréquence de PILE:\",f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A l'aide des deux dernières cellules, écrire un code simulant 25 séries de 1000 lancés à PILE ou FACE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}