From b2a1f38107396b5016bb88dccf5d4e0a1044c7fa Mon Sep 17 00:00:00 2001 From: Bertrand Benjamin Date: Sun, 11 Oct 2020 18:46:02 +0200 Subject: [PATCH] =?UTF-8?q?Feat:=20Simulation=20et=20esp=C3=A9rance=20en?= =?UTF-8?q?=20programmant=20du=20python?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../3E_esperance_simulation.ipynb | 647 ++++++++++++++++++ 1 file changed, 647 insertions(+) create mode 100644 TST/03_Variables_aleatoires/3E_esperance_simulation.ipynb diff --git a/TST/03_Variables_aleatoires/3E_esperance_simulation.ipynb b/TST/03_Variables_aleatoires/3E_esperance_simulation.ipynb new file mode 100644 index 0000000..abb0af4 --- /dev/null +++ b/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 +}