Dans le programme précédent, on répète plusieurs fois comment il faut afficher un choix.
-
-
print(" * ", entree1)
-print(" * ", entree2)
-
-
-
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.
-
Ici notre fonction va transformer le nom d'un plat en ligne de notre menu.
-
-
-
-
-
-
-
In [ ]:
-
-
-
defchoix(plat):
- return' ~ '+plat
-
-
-
-
-
-
-
-
-
-
-
On peut alors utiliser cette fonction pour présenter notre menu.
-
-
-
-
-
-
-
In [ ]:
-
-
-
entree1='Choux'
-entree2='Salade'
-plat1='Frites'
-plat2='Haricots vert'
-print("==== Menu du jour ====")
-print("")
-print("Entrées -----")
-print(choix(entree1))
-print(choix(entree2))
-print("Plats -------")
-print(" * ",plat1)
-print(" * ",plat2)
-print("")
-print("Faites votre choix")
-
-
-
-
-
-
-
-
-
-
-
-
Terminer de modifier le programme pour utiliser la fonction le plus possible.
-
Modifier la présentation d'un plat en codant une fonction.
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
+
+
+
+
+
+
+
+
+
+
+
+
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.
+
+
Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.
+
Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01.
+
+
diff --git a/PreStSauveur/Programmation/Fonctions.ipynb b/PreStSauveur/Programmation/Fonctions.ipynb
index 4b36462..628bcf0 100644
--- a/PreStSauveur/Programmation/Fonctions.ipynb
+++ b/PreStSauveur/Programmation/Fonctions.ipynb
@@ -9,10 +9,11 @@
"Le but de ce TP est de découvrir les fonctions en programmation.\n",
"\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",
"* [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"
]
},
- {
- "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",
"metadata": {},
@@ -125,7 +63,7 @@
"\n",
"On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n",
"\n",
- "Cette fonction affine\n",
+ "Cette fonction polynôme\n",
"\n",
"$$ f:x \\mapsto -x^2 + 6x+ 3$$\n",
"\n",
@@ -134,7 +72,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
@@ -209,7 +147,9 @@
"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",
"\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$."
]
},
+ {
+ "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",
"metadata": {},
diff --git a/PreStSauveur/Programmation/Simuations.html b/PreStSauveur/Programmation/Simuations.html
new file mode 100644
index 0000000..d1644e5
--- /dev/null
+++ b/PreStSauveur/Programmation/Simuations.html
@@ -0,0 +1,13436 @@
+
+
+
+
+Simuations
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
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.
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.
+
+Lorsque l'outil de simulation utilise un ordinateur on parle de simulation numérique.
+
+
+
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.
+
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.
Par défaut, Python ne sait pas faire d'aléatoire. Il faut donc importer quelques fonctions depuis random (aléatoire en anglais)
+
+
+
+
+
+
+
In [20]:
+
+
+
fromrandomimportrandom,randint,uniform,choice
+
+
+
+
+
+
+
+
+
+
+
Exécutez plusieurs fois les commandes pour vous convaincre qu'elles ne donnent pas toujours le même résultat.
+
+
random(): donne un nombre aléatoire entre 0 et 1.
+
+
+
+
+
+
+
+
In [21]:
+
+
+
random()
+
+
+
+
+
+
+
+
+
+
+
+
+
Out[21]:
+
+
+
+
+
+
0.5282588961960093
+
+
+
+
+
+
+
+
+
+
+
+
+
randint(a, b): donne un entier aléatoire entre a et b.
+
+
+
+
+
+
+
+
In [22]:
+
+
+
randint(4,10)
+
+
+
+
+
+
+
+
+
+
+
+
+
Out[22]:
+
+
+
+
+
+
8
+
+
+
+
+
+
+
+
+
+
+
+
+
uniform(a, b): donne un nombre aléatoire entre a et b.
+
+
+
+
+
+
+
+
In [23]:
+
+
+
uniform(4,10)
+
+
+
+
+
+
+
+
+
+
+
+
+
Out[23]:
+
+
+
+
+
+
6.374949885924709
+
+
+
+
+
+
+
+
+
+
+
+
+
choice(liste): choisit aléatoirement un élément de la liste.
+
+
+
+
+
+
+
+
In [26]:
+
+
+
# Pour définir une liste, on utilise des crochets []
+matieres=["math","français","Histoire"]
+# Choisir au hasard un élément parmi cette liste
+choice(matieres)
+
+
+
+
+
+
+
+
+
+
+
+
+
Out[26]:
+
+
+
+
+
+
'français'
+
+
+
+
+
+
+
+
+
+
+
+
+
Pour chaque problème qui suit, avant de vous lancer dans sa résolution, réfléchissez à la réponse que vous donneriez intuitivement.
Le frère 1: a un dé qui va de 0 à 9 et un dé de 1 à 8.
+
Le frère 2: a un dé de 1 à 12 et un dé classique 1 à 6.
+
+
On veut savoir qui sera le premier à faire 17 en ajoutant le résultat de ses 2 dés.
+
À vous de simuler cette situation pour répondre à la question.
+
+
+
+
+
+
+
In [ ]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PreStSauveur/Programmation/Simuations.ipynb b/PreStSauveur/Programmation/Simuations.ipynb
new file mode 100644
index 0000000..de36f37
--- /dev/null
+++ b/PreStSauveur/Programmation/Simuations.ipynb
@@ -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
+}