Merge branch 'master' of ssh://git_opytex:/lafrite/2020-2021 into master

TST/03_Variables_aleatoires/3E_esperance_simulation.ipynb

@@ -0,0 +1,647 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0Ntb8bau4V18"
+   },
+   "source": [
+    "# Python, Variable aléatoire et espérance\n",
+    "\n",
+    "---\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FeZvKplb4lIR"
+   },
+   "source": [
+    "## Rappel\n",
+    "\n",
+    "Dans les encadrés, il y a du code écrit dans le language Python. Pour faire **exécuter** le code, il vous faudra cliquer dessus puis appuyer sur `shift+entrer` de votre clavier. Le résultat du programme s'affichera alors en dessous.\n",
+    "\n",
+    "Nous allons travailler avec de l'aléatoire. N'hésitez pas à exécuter plusieurs fois les programmes, le résultat pourra changer."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cDLuRPVr4zbC"
+   },
+   "source": [
+    "## Génération de valeur aléatoire et affectation\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RtzRRqrD7hJp"
+   },
+   "source": [
+    "\n",
+    "Nous allons commencer par importer un module *random* qui nous permet d'utiliser des fonctions Python mathématiques avancées. \n",
+    "Pour importer des fonctions d'un module, on exécute en début de code **from** *nom_module* **import** *nom_fonction*. Si on veut importer toutes les fonctions du module, on peut aussi taper **from** *nom_module* **import** *\n",
+    "\n",
+    "*   Exécuter ce code avant toute chose\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kjj9QOtu7YoX"
+   },
+   "outputs": [],
+   "source": [
+    "from random import randint, random"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oEmS3wQV6NK0"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "*   Exécuter *une dizaine de fois* le code Python ci-dessous. Que fait-il ?\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "x04O92QV5ZpE",
+    "outputId": "838eae03-9af7-49ec-f4c6-7b3ff42dec4f"
+   },
+   "outputs": [],
+   "source": [
+    "print(randint(1,10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gbSoIN9U9-yK"
+   },
+   "source": [
+    "*   Exécuter *une dizaine de fois* le code Python ci-dessous. Que fait-il ?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "VHTA9az19_9d",
+    "outputId": "1483d01e-d3fa-455d-d4e4-4cf062e7a199"
+   },
+   "outputs": [],
+   "source": [
+    "n=randint(100,200)\n",
+    "print(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire une programme qui génère un nombre aléatoire entre 10 et 20."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire un programme qui simule un lancer d'un dé à 6 faces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9qw8LHnS9nHJ"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "*   Exécuter *une dizaine de fois* le code Python ci-dessous. Que fait-il ?\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "Yn1RF8u_7dAC",
+    "outputId": "e5ba805d-f0a2-4d49-bfcc-69ffba0be20f"
+   },
+   "outputs": [],
+   "source": [
+    "r=random()\n",
+    "print(r)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire un résumé pour expliquer le fonctionnement de `random` et de `randint`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Dans l'encadré ci-dessous, écrire un code Python suivant les instructions suivantes :\n",
+    "    - simuler deux lancers de dés successifs\n",
+    "    - afficher la somme des deux dés"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "YM1Vk5vU_GWr"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Exécuter votre programme plusieurs fois. Est-ce qu'il y a des nombres qui apparaissent plus souvent?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E0BUoBlr_2FK"
+   },
+   "source": [
+    "## Tests avec Python\n",
+    "Python peut nous permettre de tester si une variable est égale à une valeur grace à des outils de comparaison\n",
+    "\n",
+    "\n",
+    "*   Exécuter le code Python ci-dessous. Que fait-il ? Que veut dire `True` et `False`?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 52
+    },
+    "id": "F3p3_tcIAQVX",
+    "outputId": "a9e8f5ff-2c9c-4860-971d-0cd5ac71fb3e"
+   },
+   "outputs": [],
+   "source": [
+    "a=3\n",
+    "print(a==3)\n",
+    "print(a==2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "f8TvF4aSBTpk"
+   },
+   "source": [
+    "\n",
+    "*   Exécuter le code Python ci-dessous. Que fait-il ?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JyqK6_EbAehv"
+   },
+   "outputs": [],
+   "source": [
+    "print(a>1)\n",
+    "print(a<0)\n",
+    "print(a>=2)\n",
+    "print(a<=3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire un programme dans lequel vous donner une valeur à une variable puis vous faites les tests pour déterminer si cette variable est strictement plus petite que 10, égale à 10 et plus grande que 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire un résumé sur la comparaison des nombres en Python."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hbRVNyogApbV"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "- Dans l'encadré ci-dessous, écrire un code Python suivant les instructions suivantes :\n",
+    "    - simuler un lancer d'un dé classique à 6 faces\n",
+    "    - tester si le nombre obtenu est égal à 6\n",
+    "    - afficher la réponse renvoyée par le test\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Y2XAs0LMAxk_"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "x9dbzY4dBYhD"
+   },
+   "source": [
+    "## Instructions conditionnelles\n",
+    "En Python, suite à un test, on peut vouloir exécuter des instructions différentes en fonction du résultat du test.\n",
+    "\n",
+    "- Exécuter le code Python ci-dessous. Expliquer ce qu'il fait."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 52
+    },
+    "id": "lugFwQgIGTmF",
+    "outputId": "e6774df5-bdc9-4e21-fc6f-cb994eae1b06"
+   },
+   "outputs": [],
+   "source": [
+    "a=randint(1,3)\n",
+    "print(a)\n",
+    "if a>2:\n",
+    "    print('a est plus grand que 2')\n",
+    "else :\n",
+    "    print('a est plus petit ou égal à 2')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Écrire un programme qui génère un nombre entre 10 et 20. Si ce nombre est plus grand que 18, on affiche \"gagné\", sinon \"perdu\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Proposer une programme qui utilise une condition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6oOgqarGHkXj"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "- Dans l'encadré ci-dessous, écrire un code Python simulant un jeu de dés : \n",
+    "    - lancer deux dés consécutifs et stocker la somme des deux dés dans une variable `somme`\n",
+    "    - créer une variable `gain` qui vaut 0 au début du *programme*\n",
+    "    - tester la valeur de votre somme : si elle vaut au moins 10, vous gagner 10 points ; sinon, vous perdez 1 point\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kmTqw8vpIXqj"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0LjWEU-VIY72"
+   },
+   "source": [
+    "- Question mathématiques : dans l'expérience aléatoire décrite ci-dessous, le gain représente une variable aléatoire. Quelle est la loi de probabilité associée à cette variable aléatoire ? Et quelle est son espérance ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XKYOOvQ_LuNo"
+   },
+   "source": [
+    "## Réponse au hasard à un QCM\n",
+    "\n",
+    "Reprenons les exemples de l'activité \"Réponse au hasard à un QCM\".\n",
+    "\n",
+    "### Faut-il répondre?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nous allons commencer à travailler sur la questions 1 du QCM.\n",
+    "\n",
+    "- Remplacer les `#` du programme ci-dessous avec les valeurs de la question 1.\n",
+    "- Exécuter le code ci-dessous. Que fait-il ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 52
+    },
+    "id": "C1W-OfrDMJ4p",
+    "outputId": "622afcf1-7527-4647-d76e-8d2dc8381ef3"
+   },
+   "outputs": [],
+   "source": [
+    "gain_reponse_juste = #\n",
+    "proba_reponse_juste = #\n",
+    "gain_reponse_fausse= #\n",
+    "proba_reponse_fausse= #\n",
+    "\n",
+    "esperance = gain_reponse_juste*proba_reponse_juste+gain_reponse_fausse*proba_reponse_fausse\n",
+    "print(esperance)\n",
+    "\n",
+    "if esperance >= 0:\n",
+    "    print('Je peux répondre au hasard')\n",
+    "else:\n",
+    "    print('Je ne réponds pas au hasard!')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tF_epYFAM-Og"
+   },
+   "source": [
+    "- Dans les encadrés ci-dessous, écrire un code Python reprenant les données des questions 3 et 5 et permettant de décider si vous tentez de répondre à la question ou si vous décidez de ne pas répondre à la question du QCM\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iSpNLoi_NUI_"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3-23FvMfNTPO"
+   },
+   "source": [
+    "### Simulation\n",
+    "\n",
+    "On va maintenant simuler ce QCM pour évaluer votre note finale.\n",
+    "\n",
+    "\n",
+    "*   Exécuter le code suivant qui détermine à quel rang se situent les réponses justes (inutile d'essayer de le comprendre).\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Pm9Tpnf8Ngc5"
+   },
+   "outputs": [],
+   "source": [
+    "reponse_juste_question1 = randint(1,4)\n",
+    "reponse_juste_question2 = randint(1,5)\n",
+    "reponse_juste_question3 = randint(1,4)\n",
+    "reponse_juste_question4 = randint(1,5)\n",
+    "reponse_juste_question5 = randint(1,4)\n",
+    "reponse_juste1_question6 = randint(1,6)\n",
+    "reponse_juste2_question6 = randint(1,6)\n",
+    "while (reponse_juste2_question6==reponse_juste1_question6):\n",
+    "    reponse_juste2_question6=randint(1,6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fsnBjCHfOh8m"
+   },
+   "source": [
+    "*   Compléter le code suivant avec votre réponse à la question 1 puis exécuter-le. Que fait-il ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "tEpndajfOmn8",
+    "outputId": "9071c0b7-4655-4d83-83b3-3ff6ab4f8789"
+   },
+   "outputs": [],
+   "source": [
+    "ma_reponse_question1= #ajouter le numéro de votre réponse ici\n",
+    "gain=0\n",
+    "if ma_reponse_question1==reponse_juste_question1:\n",
+    "    gain=gain+2\n",
+    "else:\n",
+    "    gain=gain+0\n",
+    "print(gain)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rsNoQIKWP0mO"
+   },
+   "source": [
+    "- Dans l'encadré ci-dessous, reprendre le code Python ci-dessus pour simuler chacune de vos réponses aux 5 questions du QCM et calculer votre note finale. BONUS : ajouter la 6e question également.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "F1jCOfLPQLEl"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LWW0V4o7QM_u"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "---\n",
+    "\n",
+    "Nous allons à présent simuler une répétition de la réponse au hasard à la première question du QCM. Nous allons commencer par répéter 3 fois l'expérience.\n",
+    "- Exécuter ce code *une dizaine de fois*. Quel résultat obtenez-vous ? Expliquer ligne à ligne ce que fait ce code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 52
+    },
+    "id": "oHFkI8mfY1tk",
+    "outputId": "9987aca1-2f78-4e0f-fdd3-7650ad8becc6",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "print(esperance_question1)\n",
+    "\n",
+    "gain=0\n",
+    "\n",
+    "for i in range(3):\n",
+    "    ma_reponse_question1=randint(1,4)\n",
+    "    if ma_reponse_question1==reponse_juste_question1:\n",
+    "        gain=gain+2\n",
+    "    else:\n",
+    "        gain=gain+0\n",
+    "gain_moyen=gain/3\n",
+    "print(gain_moyen)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "e3WdV6NggmTZ"
+   },
+   "source": [
+    "Modifier le code ci-dessous pour répéter 10 fois, 100 fois, 1000 fois l'expérience. Pour chaque valeur, exécuter le code *plusieurs fois* et noter le résultat obtenu à chaque fois. Que constatez-vous ? "
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "name": "Python_VariableAleatoire&Esperance.ipynb",
+   "provenance": []
+  },
+  "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}