lafrite/2018-2019
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Feat(2nd): amélioration du tp fonction et début de simulation

Browse Source
This commit is contained in:
Bertrand Benjamin 2019-01-06 20:24:22 +01:00
parent 979c847dc6
commit 6b3140bbc2
4 changed files with 13850 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
PreStSauveur/Programmation/Fonctions.html
View File

@ -13119,11 +13119,11 @@ div#notebook {
<h1 id="Python-et-fonctions">Python et fonctions<a class="anchor-link" href="#Python-et-fonctions">&#182;</a></h1><p>Le but de ce TP est de découvrir les fonctions en programmation.</p> <h1 id="Python-et-fonctions">Python et fonctions<a class="anchor-link" href="#Python-et-fonctions">&#182;</a></h1><p>Le but de ce TP est de découvrir les fonctions en programmation.</p>
<ul> <ul>
<li><a href="#Que-fait-ce-programme?">Echauffement</a></li> <li><a href="#Que-fait-ce-programme?">Echauffement</a></li>
<li><a href="#Moins-se-répéter">Moins se répéter</a></li>
<li><a href="#Fonctions-mathématiques">Fonctions mathématiques</a></li> <li><a href="#Fonctions-mathématiques">Fonctions mathématiques</a></li>
<li><a href="#Faire-beaucoup-de-calculs">Faire beaucoup de calculs</a></li> <li><a href="#Faire-beaucoup-de-calculs">Faire beaucoup de calculs</a></li>
<li><a href="#Reçut/Recalé/mentions-au-bac">Reçut/Recalé/mentions au bac</a></li> <li><a href="#Reçut/Recalé/mentions-au-bac">Reçut/Recalé/mentions au bac</a></li>
</ul> </ul>
<p>Pour ouvrir l'environnement python: <a href="https://repl.it/repls/SpiffyOpulentBackend">repl.it</a>.</p>
</div> </div>
</div> </div>
@ -13172,80 +13172,6 @@ div#notebook {
<li>Ajouter un choix de dessert à ce programme</li> <li>Ajouter un choix de dessert à ce programme</li>
</ul> </ul>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="Moins-se-r&#233;p&#233;ter">Moins se r&#233;p&#233;ter<a class="anchor-link" href="#Moins-se-r&#233;p&#233;ter">&#182;</a></h2><p>Dans le programme précédent, on répète plusieurs fois comment il faut afficher un choix.</p>
<pre><code>print(" * ", entree1)
print(" * ", entree2)
</code></pre>
<p>C'est peu long à écrire mais surtout si l'on veut mettre un <code>~</code> au lieu d'une <code>*</code>, il faut changer chaque ligne (et donc surement en oublier!). Pour éviter d'avoir à réécrire chaque fois la même chose, on peut définir des <strong>fonctions</strong>.</p>
<p>Ici notre <strong>fonction</strong> va transformer le nom d'un plat en ligne de notre menu.</p>
</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[&nbsp;]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">choix</span><span class="p">(</span><span class="n">plat</span><span class="p">):</span>
<span class="k">return</span> <span class="s1">&#39; ~ &#39;</span><span class="o">+</span> <span class="n">plat</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>On peut alors utiliser cette fonction pour présenter notre menu.</p>
</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[&nbsp;]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">entree1</span> <span class="o">=</span> <span class="s1">&#39;Choux&#39;</span>
<span class="n">entree2</span> <span class="o">=</span> <span class="s1">&#39;Salade&#39;</span>
<span class="n">plat1</span> <span class="o">=</span> <span class="s1">&#39;Frites&#39;</span>
<span class="n">plat2</span> <span class="o">=</span> <span class="s1">&#39;Haricots vert&#39;</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;==== Menu du jour ====&quot;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;&quot;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Entrées -----&quot;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">choix</span><span class="p">(</span><span class="n">entree1</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">choix</span><span class="p">(</span><span class="n">entree2</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Plats -------&quot;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot; * &quot;</span><span class="p">,</span> <span class="n">plat1</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot; * &quot;</span><span class="p">,</span> <span class="n">plat2</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;&quot;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Faites votre choix&quot;</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<ul>
<li>Terminer de modifier le programme pour utiliser la fonction le plus possible.</li>
<li>Modifier la présentation d'un plat en codant une fonction.</li>
</ul>
</div> </div>
</div> </div>
</div> </div>
@ -13253,7 +13179,7 @@ print(" * ", entree2)
</div><div class="inner_cell"> </div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html"> <div class="text_cell_render border-box-sizing rendered_html">
<h2 id="Fonctions-math&#233;matiques">Fonctions math&#233;matiques<a class="anchor-link" href="#Fonctions-math&#233;matiques">&#182;</a></h2><p>On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques.</p> <h2 id="Fonctions-math&#233;matiques">Fonctions math&#233;matiques<a class="anchor-link" href="#Fonctions-math&#233;matiques">&#182;</a></h2><p>On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques.</p>
<p>Cette fonction affine</p> <p>Cette fonction polynôme</p>
$$ f:x \mapsto -x^2 + 6x+ 3$$<p>se codera en python</p> $$ f:x \mapsto -x^2 + 6x+ 3$$<p>se codera en python</p>
</div> </div>
@ -13261,7 +13187,7 @@ $$ f:x \mapsto -x^2 + 6x+ 3$$<p>se codera en python</p>
</div> </div>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <div class="input">
<div class="prompt input_prompt">In&nbsp;[&nbsp;]:</div> <div class="prompt input_prompt">In&nbsp;[2]:</div>
<div class="inner_cell"> <div class="inner_cell">
<div class="input_area"> <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span> <div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
@ -13350,6 +13276,7 @@ $$ f:x \mapsto -x^2 + 6x+ 3$$<p>se codera en python</p>
<div class="text_cell_render border-box-sizing rendered_html"> <div class="text_cell_render border-box-sizing rendered_html">
<p>Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.</p> <p>Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.</p>
<p>Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser <strong> une boucle </strong> <code>for</code>.</p> <p>Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser <strong> une boucle </strong> <code>for</code>.</p>
<p>Ici la boucle va calculer les images par la fonction $f$ de tous les nombres de 0 à 9.</p>
</div> </div>
</div> </div>
@ -13377,6 +13304,81 @@ $$ f:x \mapsto -x^2 + 6x+ 3$$<p>se codera en python</p>
<li>Trouver le maximum de la fonction $g$.</li> <li>Trouver le maximum de la fonction $g$.</li>
</ul> </ul>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>On peut aussi utiliser une boucle <code>while</code> (tant que).</p>
<p>Ici, on va calculer les images par la fonction $f$ des nombres entre 2 et 4 avec un pas de 0,1.</p>
</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[3]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">pas</span> <span class="o">=</span> <span class="mf">0.1</span>
<span class="k">while</span> <span class="n">x</span> <span class="o">&lt;=</span> <span class="mi">4</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Quand x vaut&quot;</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="s2">&quot;f(x) vaut &quot;</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mf">0.1</span>
</pre></div>
</div>
</div>
</div>
<div class="output_wrapper">
<div class="output">
<div class="output_area">
<div class="prompt"></div>
<div class="output_subarea output_stream output_stdout output_text">
<pre>Quand x vaut 2 f(x) vaut 5
Quand x vaut 2.1 f(x) vaut 5.190000000000001
Quand x vaut 2.2 f(x) vaut 5.359999999999999
Quand x vaut 2.3000000000000003 f(x) vaut 5.51
Quand x vaut 2.4000000000000004 f(x) vaut 5.640000000000001
Quand x vaut 2.5000000000000004 f(x) vaut 5.75
Quand x vaut 2.6000000000000005 f(x) vaut 5.84
Quand x vaut 2.7000000000000006 f(x) vaut 5.91
Quand x vaut 2.8000000000000007 f(x) vaut 5.960000000000001
Quand x vaut 2.900000000000001 f(x) vaut 5.99
Quand x vaut 3.000000000000001 f(x) vaut 6.000000000000002
Quand x vaut 3.100000000000001 f(x) vaut 5.989999999999998
Quand x vaut 3.200000000000001 f(x) vaut 5.959999999999999
Quand x vaut 3.300000000000001 f(x) vaut 5.91
Quand x vaut 3.4000000000000012 f(x) vaut 5.839999999999998
Quand x vaut 3.5000000000000013 f(x) vaut 5.749999999999998
Quand x vaut 3.6000000000000014 f(x) vaut 5.639999999999999
Quand x vaut 3.7000000000000015 f(x) vaut 5.509999999999998
Quand x vaut 3.8000000000000016 f(x) vaut 5.359999999999999
Quand x vaut 3.9000000000000017 f(x) vaut 5.189999999999996
</pre>
</div>
</div>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered"><div class="prompt input_prompt">
</div><div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Les nombreux chiffres après la virgules (qui sont faux!) viennent de la façon de stocker les nombres à virgules dans l'ordinateur. Ils sont présents dans la majorité des programmes et il est difficile de les éviter. C'est une des raison pour laquelle on ne peut pas faire aveuglément confiance à un ordinateur.</p>
<ul>
<li>Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.</li>
<li>Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01.</li>
</ul>
</div> </div>
</div> </div>
</div> </div>

135
PreStSauveur/Programmation/Fonctions.ipynb
View File

@ -9,10 +9,11 @@
"Le but de ce TP est de découvrir les fonctions en programmation.\n", "Le but de ce TP est de découvrir les fonctions en programmation.\n",
"\n", "\n",
"* [Echauffement](#Que-fait-ce-programme?)\n", "* [Echauffement](#Que-fait-ce-programme?)\n",
"* [Moins se répéter](#Moins-se-répéter)\n",
"* [Fonctions mathématiques](#Fonctions-mathématiques)\n", "* [Fonctions mathématiques](#Fonctions-mathématiques)\n",
"* [Faire beaucoup de calculs](#Faire-beaucoup-de-calculs)\n", "* [Faire beaucoup de calculs](#Faire-beaucoup-de-calculs)\n",
"* [Reçut/Recalé/mentions au bac](#Reçut/Recalé/mentions-au-bac)" "* [Reçut/Recalé/mentions au bac](#Reçut/Recalé/mentions-au-bac)\n",
"\n",
"Pour ouvrir l'environnement python: [repl.it](https://repl.it/repls/SpiffyOpulentBackend). "
] ]
}, },
{ {
@ -54,69 +55,6 @@
"* Ajouter un choix de dessert à ce programme" "* Ajouter un choix de dessert à ce programme"
] ]
}, },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Moins se répéter\n",
"\n",
"Dans le programme précédent, on répète plusieurs fois comment il faut afficher un choix.\n",
"\n",
" print(\" * \", entree1)\n",
" print(\" * \", entree2)\n",
"\n",
"C'est peu long à écrire mais surtout si l'on veut mettre un `~` au lieu d'une `*`, il faut changer chaque ligne (et donc surement en oublier!). Pour éviter d'avoir à réécrire chaque fois la même chose, on peut définir des **fonctions**.\n",
"\n",
"Ici notre **fonction** va transformer le nom d'un plat en ligne de notre menu."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def choix(plat):\n",
" return ' ~ '+ plat"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut alors utiliser cette fonction pour présenter notre menu."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"entree1 = 'Choux'\n",
"entree2 = 'Salade'\n",
"plat1 = 'Frites'\n",
"plat2 = 'Haricots vert'\n",
"print(\"==== Menu du jour ====\")\n",
"print(\"\")\n",
"print(\"Entrées -----\")\n",
"print(choix(entree1))\n",
"print(choix(entree2))\n",
"print(\"Plats -------\")\n",
"print(\" * \", plat1)\n",
"print(\" * \", plat2)\n",
"print(\"\")\n",
"print(\"Faites votre choix\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Terminer de modifier le programme pour utiliser la fonction le plus possible.\n",
"* Modifier la présentation d'un plat en codant une fonction."
]
},
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
@ -125,7 +63,7 @@
"\n", "\n",
"On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n", "On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n",
"\n", "\n",
"Cette fonction affine\n", "Cette fonction polynôme\n",
"\n", "\n",
"$$ f:x \\mapsto -x^2 + 6x+ 3$$\n", "$$ f:x \\mapsto -x^2 + 6x+ 3$$\n",
"\n", "\n",
@ -134,7 +72,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": 2,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
@ -209,7 +147,9 @@
"source": [ "source": [
"Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.\n", "Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.\n",
"\n", "\n",
"Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser ** une boucle ** `for`." "Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser ** une boucle ** `for`.\n",
"\n",
"Ici la boucle va calculer les images par la fonction $f$ de tous les nombres de 0 à 9. "
] ]
}, },
{ {
@ -232,6 +172,65 @@
"* Trouver le maximum de la fonction $g$." "* Trouver le maximum de la fonction $g$."
] ]
}, },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi utiliser une boucle `while` (tant que).\n",
"\n",
"Ici, on va calculer les images par la fonction $f$ des nombres entre 2 et 4 avec un pas de 0,1."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Quand x vaut 2 f(x) vaut 5\n",
"Quand x vaut 2.1 f(x) vaut 5.190000000000001\n",
"Quand x vaut 2.2 f(x) vaut 5.359999999999999\n",
"Quand x vaut 2.3000000000000003 f(x) vaut 5.51\n",
"Quand x vaut 2.4000000000000004 f(x) vaut 5.640000000000001\n",
"Quand x vaut 2.5000000000000004 f(x) vaut 5.75\n",
"Quand x vaut 2.6000000000000005 f(x) vaut 5.84\n",
"Quand x vaut 2.7000000000000006 f(x) vaut 5.91\n",
"Quand x vaut 2.8000000000000007 f(x) vaut 5.960000000000001\n",
"Quand x vaut 2.900000000000001 f(x) vaut 5.99\n",
"Quand x vaut 3.000000000000001 f(x) vaut 6.000000000000002\n",
"Quand x vaut 3.100000000000001 f(x) vaut 5.989999999999998\n",
"Quand x vaut 3.200000000000001 f(x) vaut 5.959999999999999\n",
"Quand x vaut 3.300000000000001 f(x) vaut 5.91\n",
"Quand x vaut 3.4000000000000012 f(x) vaut 5.839999999999998\n",
"Quand x vaut 3.5000000000000013 f(x) vaut 5.749999999999998\n",
"Quand x vaut 3.6000000000000014 f(x) vaut 5.639999999999999\n",
"Quand x vaut 3.7000000000000015 f(x) vaut 5.509999999999998\n",
"Quand x vaut 3.8000000000000016 f(x) vaut 5.359999999999999\n",
"Quand x vaut 3.9000000000000017 f(x) vaut 5.189999999999996\n"
]
}
],
"source": [
"x = 2\n",
"pas = 0.1\n",
"while x <= 4:\n",
" print(\"Quand x vaut\", x, \"f(x) vaut \", f(x))\n",
" x = x + 0.1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les nombreux chiffres après la virgules (qui sont faux!) viennent de la façon de stocker les nombres à virgules dans l'ordinateur. Ils sont présents dans la majorité des programmes et il est difficile de les éviter. C'est une des raison pour laquelle on ne peut pas faire aveuglément confiance à un ordinateur.\n",
"\n",
"* Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.\n",
"* Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01."
]
},
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},

13436
PreStSauveur/Programmation/Simuations.html Normal file
View File

File diff suppressed because it is too large Load Diff

268
PreStSauveur/Programmation/Simuations.ipynb Normal file
View File

@ -0,0 +1,268 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Échauffements\n",
"\n",
"Copier-coller ligne par ligne le programme suivant en corrigeant les éventuelles erreurs. Une fois le programme relu et corrigé, proposer puis coder une amélioration."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Simulation de phénomènes aléatoires\n",
"\n",
"D'après wikipedia\n",
"\n",
" La simulation est un outil utilisé par le chercheur, l'ingénieur, le militaire, etc. pour étudier les résultats d'une action sur un élément sans réaliser l'expérience sur l'élément réel.\n",
"\n",
" Lorsque l'outil de simulation utilise un ordinateur on parle de simulation numérique.\n",
" \n",
"La simulation sert à produire des **données** à partir d'un modèle, d'une expérience. Ces données servent ensuite à valider le modèle ou à analyser l'expérience.\n",
"\n",
"Dans ce TP, vous allez modéliser puis simuler des expériences aléatoires. Il vous faudra d'abord choisir les bons outils pour reproduire informatiquement l'expérience puis la faire jouer par l'ordinateur de nombreuses fois."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les fonctions random\n",
"\n",
"Par défaut, Python ne sait pas faire d'aléatoire. Il faut donc importer quelques fonctions depuis `random` (aléatoire en anglais)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"from random import random, randint, uniform, choice"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exécutez plusieurs fois les commandes pour vous convaincre qu'elles ne donnent pas toujours le même résultat.\n",
"\n",
"- `random()`: donne un nombre aléatoire entre 0 et 1."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.5282588961960093"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"random()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `randint(a, b)`: donne un entier aléatoire entre a et b."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"randint(4, 10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `uniform(a, b)`: donne un nombre aléatoire entre a et b."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6.374949885924709"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"uniform(4, 10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `choice(liste)`: choisit aléatoirement un élément de la liste."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'français'"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Pour définir une liste, on utilise des crochets []\n",
"matieres = [\"math\", \"français\", \"Histoire\"]\n",
"# Choisir au hasard un élément parmi cette liste\n",
"choice(matieres)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"Pour chaque problème qui suit, avant de vous lancer dans sa résolution, réfléchissez à la réponse que vous donneriez intuitivement.\n",
"\n",
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Jeux de dés\n",
"\n",
"On veut jouer à un jeu de hasard, le but est d'avoir le plus haut score. Pour cela nous pouvons choisir l'une des trois situations suivantes:\n",
"\n",
"- Situation 1: On lance deux dés à douze faces numérotées de 1 à 12 et on ajoute les scores.\n",
"- Situation 2: On lance quatre dés à 6 faces numérotées de 1 à 6 et on ajoute des scores.\n",
"\n",
"On supposera que tous les dés sont équilibrés.\n",
"\n",
"**On souhaite savoir quelle est la situation la plus avantageuse.**\n",
"\n",
"Pour répondre à cette question, on propose les étapes suivantes.\n",
"\n",
"1. Simuler la situation 2. Y a-t-il des nombres qui semblent revenir plus souvent que les autres?\n",
"2. Simuler la situation 3. Même question.\n",
"3. Simuler les 2 situations en même temps. Quelle est celle qui semble la plus avantageuse?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Dés de Efrons\n",
"\n",
"On dispose de 3 dés à 6 faces équilibrés avec les nombres suivants sur leurs faces.\n",
"\n",
"- A : 1, 6, 11, 12, 13, 14\n",
"- B : 2, 3, 4, 15, 16, 17\n",
"- C : 5, 7, 8, 9, 10, 18\n",
"\n",
"**On souhaite savoir si un dé est plus avantageux que les autres.**\n",
"\n",
"Proposition d'étapes pour répondre à cette question\n",
"\n",
"1. Simuler le lancer de ces 3 dés.\n",
"2. Simuler en même temps les dés A et B. Lequel semble donner le meilleur score?\n",
"3. Faire la même chose avec les dés A et C puis avec les dés B et C.\n",
"4. Y a-t-il un dé plus fort que les autres?\n",
"5. Simuler le lancer des 3 dés en même temps lequel semble le plus fort?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les dés des Dudu\n",
"\n",
"Dans [le problème des dés des Dudu](https://mathix.org/video/problemes_ouverts/PB_DUDU/PBDUDU7-d%C3%A9.mp4), les deux frères ont chacun deux dés différents:\n",
"\n",
"- Le frère 1: a un dé qui va de 0 à 9 et un dé de 1 à 8.\n",
"- Le frère 2: a un dé de 1 à 12 et un dé classique 1 à 6.\n",
"\n",
"**On veut savoir qui sera le premier à faire 17 en ajoutant le résultat de ses 2 dés.**\n",
"\n",
"À vous de simuler cette situation pour répondre à la question."
]
},
{
"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.7.1"
}
},
"nbformat": 4,
"nbformat_minor": 2
}