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

Import all

Browse Source
This commit is contained in:
Bertrand Benjamin
2020-05-05 09:53:14 +02:00
parent 0e4c9c0fea
commit 7de4bab059
1411 changed files with 163444 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1220
1ST/Programmation/1-Projets_Python.ipynb Normal file
View File

File diff suppressed because it is too large Load Diff

286
1ST/Programmation/2-Fonctions.ipynb Normal file
View File

@@ -0,0 +1,286 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python et fonctions\n",
"\n",
"Le but de ce TP est de découvrir les fonctions en programmation.\n",
"\n",
"* [Echauffement](#Que-fait-ce-programme?)\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)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Que fait ce programme?\n",
"\n",
"* Copier puis coller le programme, l'executer. Fait-il ce que vous attendiez de lui?\n",
"* Commenter au dessus de chaque ligne (avec #...) pour expliquer ce qu'elle fait."
]
},
{
"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(\" * \", entree1)\n",
"print(\" * \", entree2)\n",
"print(\"Plats -------\")\n",
"print(\" * \", plat1)\n",
"print(\" * \", plat2)\n",
"print(\"\")\n",
"print(\"Faites votre choix\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ajouter un choix de dessert à ce programme"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonctions mathématiques \n",
"\n",
"On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n",
"\n",
"Cette fonction polynôme\n",
"\n",
"$$ f:x \\mapsto -x^2 + 6x+ 3$$\n",
"\n",
"se codera en python"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def f(x):\n",
" return -x**2+6*x-3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Maintenant que la fonction est codée, on peut l'utiliser pour calculer des images."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(f(10))\n",
"print(f(-2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour chacune des fonctions suivantes, testées les pour savoir si elles fonctionnents. Une fois que vous ètes sûr qu'elles font bien ce que vous souhaitez, ne les effacées pas et gardez les pour la suite.\n",
"\n",
"* Programmer la fonction $g$ définie par \n",
" $$ g:x \\mapsto x(19 - 2x) $$\n",
" \n",
"* Programmer la fonction $h$ qui correspond au programme de calcul suivant\n",
"\n",
" * Choisir un nombre\n",
" * -> Ajouter 2\n",
" * -> Elever au carré\n",
" * -> Soustraire 4\n",
" \n",
"* Programmer une fonction `celcius2fahrenheit` qui convertit des degrés celcius vers des degrés fahrenheit en utilisant la formule suivante\n",
" $$ (°F) = 1,8 * (°C) + 32 $$\n",
"\n",
"* Programmer la fonction inverse `fahrenheit2celcius`.\n",
"\n",
"Les 2 prochaines parties peuvent être faite independament. A vous de choisir celle qui tente le plus."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Faire beaucoup de calculs\n",
"\n",
"Imaginons que je souhaite chercher le maximum de la fonction $f$ programmée précédement. Il va falloir que je fasse calculer à python plusieurs images de cette fonction.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(f(0))\n",
"print(f(5))\n",
"print(f(20))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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`.\n",
"\n",
"Ici la boucle va calculer les images par la fonction $f$ de tous les nombres de 0 à 9. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for x in range(10):\n",
" print(\"Quand x vaut\", x, \", f(x) vaut\", f(x))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut donc penser que la fonction a un maximum autour de 3.\n",
"\n",
"* Ecrire toutes les conversions 0 à 100 degré celcius en farhenheit\n",
"* 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": {},
"source": [
"## Reçut/Recalé/mentions au bac\n",
"\n",
"Au bac, on applique le barème suivant:\n",
"\n",
"* Note strictement inférieure à 10: recalé\n",
"* Note supérieure à 10: reçut\n",
"\n",
"On peut y voir une fonction qui transforme une *note* en l'un des deux mots *recalé* ou *reçut*.\n",
"\n",
"* Programmer cette fonction (aller voir du coté des `if` dans le mémo).\n",
"\n",
"Parmi les reçuts, certains peuvent avoir des mentions:\n",
"\n",
"* $10 \\leq note < 12 $: pas de mentions\n",
"* $12 \\leq note < 14 $: Assez Bien\n",
"* $14 \\leq note < 16 $: Bien\n",
"* $16 \\leq note $: Très Bien\n",
"\n",
"* Programmer cette fonction qui transforme une note en la mention."
]
},
{
"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.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

278
1ST/Programmation/3-Simuations.ipynb Normal file
View File

@@ -0,0 +1,278 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Échauffements\n",
"\n",
"- [ ] Copier-coller blocspar blocs le programme suivant en corrigeant les éventuelles erreurs (il y en a au moins une par bloc)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\"Je veux calculer le périmètre et l'aire de cercles\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"print(\"Pour cela j'ai besoin de Pi\")\n",
"pi = 3.14\n",
"print(\"Je sais que pi vaut pi\")\n",
"print(\"Mais Python connait une valeur approchée plus précise de pi, elle vaut\", math.pi)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Je veux calculer le périmètre d'un cercle\")\n",
"rayon = 3\n",
"print(\"Quand le rayon vaut\", rayon, \"le périmètre vaut\", 2*math.pi*5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"On peut en faire une fonction\")\n",
"def perimetre(rayon)\n",
"return 4*math.pi*rayon\n",
"print(\"Le périmètre d'un cercle de rayon 2 est \", perimetre(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- [ ] Ecrire une fonction qui calcule l'aire d'un cercle à partir de son rayon.\n",
"- [ ] Copier-coller, tester ce bloc puis expliquer avec # ce qu'il fait."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"rayon = 10\n",
"print(\"J'ai un cercle de rayon\", rayon)\n",
"if rayon < 50:\n",
" print(\"C'est un petit cercle.\")\n",
"else:\n",
" print(\"C'est un grand cercle!\")\n",
"print(\"Son périmètre vaut\", perimetre(rayon))"
]
},
{
"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": null,
"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": null,
"metadata": {},
"outputs": [],
"source": [
"random()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `randint(a, b)`: donne un entier aléatoire entre a et b."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"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": null,
"metadata": {},
"outputs": [],
"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": null,
"metadata": {},
"outputs": [],
"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."
]
}
],
"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.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

232
1ST/Programmation/4-Simulations_repetitions.ipynb Normal file
View File

@@ -0,0 +1,232 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Simulation et évaluation\n",
"\n",
"Dans ce TP les consignes en orange correspondent à consignes qui seront évaluées. Comme d'habitude, vous avez tout à faire le droit d'échanger avec vos voisins et d'aller chercher des informations dans les TPs précédents.\n",
"\n",
"## Echauffement et pyramide\n",
"\n",
"D'après wikipedia:\n",
"\n",
" La pyramide de Khéops ou grande pyramide de Gizeh est un monument construit par les Égyptiens de l'Antiquité, formant une pyramide à base carrée. Tombeau présumé du pharaon Khéops, elle fut édifiée il y a plus de 4 500 ans, sous la IVe dynastie, au centre du complexe funéraire de Khéops se situant à Gizeh en Égypte. \n",
" \n",
" Ce monument forme une pyramide à base carrée de 440 coudées royales anciennes, soit environ 230,5 mètres. Il est constitué d'environ 2 000 000 blocs de pierre calcaire d'environ 2,5tonnes chacuns. \n",
" \n",
"\n",
"<div style=\"background-color: #fa8258;\">\n",
"Ecrire un programme qui présente cette pyramide. Il devra aussi calculer la périmètre de la base de la pyramide ainsi qu'une estimation de son poid total.\n",
" \n",
"Critères d'évaluations:\n",
"<ul>\n",
" <li> Réspect de la consigne (présentation et grandeurs à calculer)</li>\n",
" <li> Utilisation de variables pour le calcul du périmètre et du poids de la pyramide. </li>\n",
" <li> <strong>Bonus:</strong> le calcule du périmètre se fera avec une fonction.\n",
"</ul>\n",
" <strong> Sauver votre programme dans \"Ordinateur > Ma classe > Restitution de Devoirs\" en le nommant</strong> <code>nom-prénom-pyramide.py</code> (Mettre les 2 noms de familles si vous travaillez à 2).\n",
"</div> \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Simulation de dés\n",
"\n",
"<div style=\"background-color: #fa8258;\">\n",
"Copier-coller le bloc le programme suivant. Puis commenter (avec #) pour expliquer ce que fait chaque ligne.\n",
"</div>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from random import randint # Import de randint qui génère un entier aléatoire entre 2 nombres.\n",
"print(\"--- Simulateur de lancer de dés ---\")\n",
"print(\"Première situation\")\n",
"de1 = randint(1, 6)\n",
"de2 = randint(1, 10)\n",
"resulat1 = de1 * de2\n",
"print(\"La première situation donne\", resulat1)\n",
"print(\"Deuxième situation\")\n",
"resulat2 = randint(1, 8) * randint(1, 8)\n",
"print(\"La deuxième situation donne\", resulat2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<div style=\"background-color: #fa8258;\">\n",
"Transformer le programme pour qu'il simule les deux situations suivantes:\n",
"<ul>\n",
" <li> Situation 1: On fait la somme des résultats des lancers de 2 dés à 18 faces.</li>\n",
" <li> Situation 2: On fait le produit des résultats des lancers de deux dés à 3 faces et d'un dé à 4 faces.</li>\n",
"</ul>\n",
"</br>\n",
"Vous ètes invités à apporter toutes les améliorations qui vous semblent interessantes.\n",
"</br>\n",
"</br>\n",
"Vous serez noté suivant les critères suivants:\n",
"<ul>\n",
" <li> Qualité des commentaires qui expliquent le fonctionnement du programme.</li>\n",
" <li> Fonctionnement de votre programme et respect de la consigne.</li>\n",
" <li> Qualité des améliorations apportées.</li>\n",
"</ul>\n",
"<strong> Sauver votre programme dans \"Ordinateur > Ma classe > Restitution de Devoirs\" en le nommant</strong> <code>nom-prénom-simlulation.py</code> (Mettre les 2 noms de familles si vous travaillez à 2).\n",
"</div> \n",
" \n",
"- [ ] Copier-coller le bloc à la suite. Puis commenter."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"if resulat1 > resulat2:\n",
" print(\"La première situation gagne\")\n",
"else:\n",
" print(\"La deuxième situation gagne\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- [ ] Quelle situation semble donner le score le plus grand?\n",
"- [ ] Ouvrir un nouveau fichier, copier-coller le programme suivant puis commenter chaque ligne pour expliquer son fonctionnement."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from random import randint\n",
"\n",
"print(\"--- Simulateur de lancer de dés ---\")\n",
"\n",
"for i in range(10):\n",
" print(\"---------------------\")\n",
" print(\"# Simulation numéro\", i+1)\n",
" \n",
" print(\"Première situation\")\n",
" de1 = randint(1, 6)\n",
" de2 = randint(1, 10)\n",
" resulat1 = de1 * de2\n",
" print(\"La première situation donne\", resulat1)\n",
" \n",
" print(\"Deuxième situation\")\n",
" resulat2 = randint(1, 8) * randint(1, 8)\n",
" print(\"La deuxième situation donne\", resulat2)\n",
" \n",
" if resulat1 > resulat2:\n",
" print(\"-> La première situation gagne.\")\n",
" else:\n",
" print(\"-> La deuxième situation gagne.\")"
]
},
{
"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": [
"## 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",
"<div style=\"background-color: #fa8258;\">\n",
"\n",
"**Vous enregistrez votre programme dans \"Ordinateur > Ma classe > Restitution de Devoirs\" sous le nom** `nom-prénom-deEfron.py`\n",
"\n",
"</div>\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?\n",
"\n",
"Astuces pour simuler les lancés de dés:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"from random import choice\n",
"# On définit les valeurs inscrites sur chaque face\n",
"deA = [1, 6, 11, 12, 13, 14]\n",
"# Python choisi une face au hasard\n",
"print(choice(deA))"
]
},
{
"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."
]
}
],
"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.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

350
1ST/Programmation/5-listes_et_fonctions.ipynb Normal file
View File

@@ -0,0 +1,350 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Listes et fonctions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Graphique de fonctions\n",
"\n",
"Nous allons tracer la représentation graphique de \n",
"\n",
"$$ f : x \\mapsto x^2 - 10x + 20 $$\n",
"\n",
"**Recopier** le programme suivant, **compléter** les pointillés et calculer les images jusqu'à 8."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"L'image de ... est ...\n",
"L'image de ... est ...\n"
]
}
],
"source": [
"def f(x):\n",
" return x**2 - 10*x + 20\n",
"\n",
"# image de 0\n",
"print(\"L'image de\", \"...\",\" est\", \"...\")\n",
"# image de 1\n",
"print(\"L'image de\", \"...\",\" est\", \"...\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour tracer le graphique de cette fonction, il faudrait *enregistrer* toutes ces valeurs et donc utiliser des variables. \n",
"\n",
"Mettre plusieurs valeurs dans une seule variable c'est possible, on utilise des `listes` (on les a déjà rencontré plusieurs fois).\n",
"\n",
"**Recopier et compléter** ce programme pour enregistrer les images et les antécédents jusqu'à 10."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"L'image de ... est ... On l'ajoute à la liste\n",
"L'image de ... est ... On l'ajoute à la liste\n"
]
}
],
"source": [
"def f(x):\n",
" return x**2/10 - 5\n",
"\n",
"images = [] # La liste est vide\n",
"antecedents = []\n",
"\n",
"\n",
"# image de 0\n",
"print(\"L'image de\", \"...\",\" est\", \"...\", \"On l'ajoute à la liste\")\n",
"antecedents.append(0) # On ajoute (append) 0 à la liste des antecedents\n",
"# image de 1\n",
"print(\"L'image de\", \"...\",\" est\", \"...\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nous allons maintenant enfin pouvoir tracer le graphique.\n",
"\n",
"**Ajouter** la ligne suivante au début de votre programme."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ajouter** cette ligne à la fin."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(antecedants, images)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Vous avez tracer la courbe représentative de de la fonction $f$.\n",
"\n",
"![Représentation graphique de f](./fig/plt_f.png)\n",
"\n",
"Dans un nouveau fichier, **tracer** la courbe représentative pour x allant de 0 à 15 de la fonction $g$ tel que\n",
"$$ g : x \\mapsto -(x - 5)^2 + 5$$\n",
"\n",
"![Représentation graphique de f](./fig/plt_g.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Précision et controle du tracé\n",
"\n",
"Pour le moment, on sait donner un maximum à l'antécédent $x$ mais on ne peut pas contrôler le minimum ni le pas (l'écart en 2 valeurs de $x$). \n",
"\n",
"Or pour tracer précisément la représentation graphique d'une fonction, nous avons besoin de contrôler la **fenêtre** (minimum et maximum) et le **pas**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucle `while` (tant que )\n",
"\n",
"Une boucle `while` permet de répeter une ou plusieurs actions **tant qu'** une condition est vérifiée.\n",
"\n",
"Les 2 programmes ci-dessous font la même chose."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"x = 0\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1\n",
"\n",
"print(x)\n",
"x = x+1"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"x = 0\n",
"while x < 10:\n",
" print(x)\n",
" x = x + 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Commenter** le programme avec le `while`.\n",
"\n",
"Que se passe-t-il si on inverse les 2 dernières lignes?\n",
"\n",
"**Réécrire** le programme suivant en utilisant une boucle `while` et en stockant les antécédents."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Les images sont [0.0, 1.0, 1.2246467991473532e-16, -1.0, -2.4492935982947064e-16, 1.0, 3.6739403974420594e-16, -1.0, -4.898587196589413e-16, 1.0, 6.123233995736766e-16, -1.0, -7.347880794884119e-16, 1.0, 8.572527594031472e-16, -1.0, -9.797174393178826e-16, 1.0, 1.102182119232618e-15, -1.0]\n"
]
}
],
"source": [
"from math import sin, pi\n",
"\n",
"def h(x):\n",
" return sin(x*pi/2)\n",
"\n",
"images = []\n",
"antecedants = []\n",
"\n",
"# image de 0\n",
"print(\"L'image de\", \"...\",\" est\", \"...\", \"On les ajoute à la liste\")\n",
"antecedents.append(0)\n",
"images.append(h(0))\n",
"\n",
"# image de 1\n",
"print(\"L'image de\", \"...\",\" est\", \"...\", \"On les ajoute à la liste\")\n",
"antecedents.append(1)\n",
"images.append(h(1))\n",
"\n",
"# ....\n",
"\n",
"# image de 20\n",
"print(\"L'image de\", \"...\",\" est\", \"...\", \"On les ajoute à la liste\")\n",
"antecedents.append(20)\n",
"images.append(h(20))\n",
"\n",
"print(\"Les images sont \", images)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Modifier** votre programme pour que les antécédents aillent de -2 à 2.\n",
"\n",
"**Modifier** votre programme pour que les antécédents augmentent avec un pas de 0.5 au lieu de 1.\n",
"\n",
"**Tracer** sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 1. \n",
"\n",
"**Tracer** sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.5. \n",
"\n",
"**Tracer** sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.1.\n",
"\n",
"En regroupant les 3 programmes écrit précedement, **tracer** sur le même graphique les 3 représentations pour observer l'amélioration de la précision.\n",
"\n",
"*Astuce*: pour tracer 3 graphiques en 1, on fait les `plt.plot(...)` de chaque graphique et uniquement à la fin on lance `plt.show()`.\n",
"\n",
"![Comparaison des pas](./fig/comp_sin.png)"
]
},
{
"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.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

1002
1ST/Programmation/Memo.ipynb Normal file
View File

File diff suppressed because one or more lines are too long