From 0bfbc1142c27d8b02cb8789b3fc49f7a13b374b7 Mon Sep 17 00:00:00 2001 From: Bertrand Benjamin Date: Mon, 11 Mar 2019 11:15:30 +0100 Subject: [PATCH] =?UTF-8?q?Feat:=205e=20s=C3=A9ance=20python=20avec=20les?= =?UTF-8?q?=202nd?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Programmation/5-listes et fonctions.html | 13379 ++++++++++++++++ .../Programmation/5-listes et fonctions.ipynb | 254 + .../5-listes et fonctions_sol.ipynb | 134 + PreStSauveur/Programmation/fig/comp_sin.png | Bin 0 -> 21011 bytes PreStSauveur/Programmation/fig/cos_pas1.png | Bin 0 -> 17688 bytes PreStSauveur/Programmation/fig/g_pas1.png | Bin 0 -> 9669 bytes 6 files changed, 13767 insertions(+) create mode 100644 PreStSauveur/Programmation/5-listes et fonctions.html create mode 100644 PreStSauveur/Programmation/5-listes et fonctions.ipynb create mode 100644 PreStSauveur/Programmation/5-listes et fonctions_sol.ipynb create mode 100644 PreStSauveur/Programmation/fig/comp_sin.png create mode 100644 PreStSauveur/Programmation/fig/cos_pas1.png create mode 100644 PreStSauveur/Programmation/fig/g_pas1.png diff --git a/PreStSauveur/Programmation/5-listes et fonctions.html b/PreStSauveur/Programmation/5-listes et fonctions.html new file mode 100644 index 0000000..1dfcb24 --- /dev/null +++ b/PreStSauveur/Programmation/5-listes et fonctions.html @@ -0,0 +1,13379 @@ + + + + +5-listes et fonctions + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Listes et fonctions

+
+
+
+
+
+
+

Graphique de fonctions

Dans cet échauffement, nous allons calculer les images d'une fonction pour tracer sa représentation graphique.

+

Recopier le programme suivant.

+

Modifier la ligne avec le print pour faire apparaitre l'image et l'antécédent à chaque ligne.

+

Commenter chaque ligne avec une attention particulière à la ligne qui commence par for...

+ +
+
+
+
+
+
In [ ]:
+
+
+
from math import cos, pi
+
+def f(x):
+    return cos(x*pi/2)
+
+for x in range(40):
+    print(f(x))
+
+ +
+
+
+ +
+
+
+
+

Pour tracer le graphique de cette fonction, il faudrait enregistrer toutes ces valeurs et donc utiliser des variables.

+

Mettre plusieurs valeurs dans une seule variable c'est possible, on utilise des listes (on les a déjà rencontré plusieurs fois).

+

Recopier ce programme, commenter ce programme et retrouver où les listes apparaissent.

+ +
+
+
+
+
+
In [ ]:
+
+
+
from math import cos, pi
+
+def f(x):
+    return cos(x*pi/2)
+
+images = []
+antecedants = []
+
+for x in range(20):
+    images.append(f(x))
+
+print("Les images sont ", images)
+
+ +
+
+
+ +
+
+
+
+

Modifier votre programme pour enregistrer aussi les antecedants et les afficher à la fin

+

Nous allons maintenant enfin pouvoir tracer le graphique.

+

Ajouter la ligne suivante au début de votre programme.

+ +
+
+
+
+
+
In [ ]:
+
+
+
import matplotlib.pyplot as plt
+
+ +
+
+
+ +
+
+
+
+

Ajouter cette ligne à la fin.

+ +
+
+
+
+
+
In [ ]:
+
+
+
plt.plot(antecedants, images)
+plt.show()
+
+ +
+
+
+ +
+
+
+
+

Vous avez tracer la courbe représentative de de la fonction $f$.

+

Représentation graphique de f

+

Dans un nouveau fichier, tracer la courbe représentative de la fonction $g$ tel que +$$ g : x \mapsto x^2 - 4$$

+

Représentation graphique de f

+ +
+
+
+
+
+
+

Précision et controle du tracé

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$). 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.

+ +
+
+
+
+
+
+

Boucle while (tant que )

Ce type de boucle donne plus de contrôle sur $x$ et nous évite d'utiliser range qui est une commande qui n'existe que en Python.

+

Les 2 programmes ci-dessous font la même chose.

+ +
+
+
+
+
+
In [ ]:
+
+
+
for x in range(10):
+    print(x)
+
+ +
+
+
+ +
+
+
+
In [ ]:
+
+
+
x = 0
+while x < 10:
+    print(x)
+    x = x + 1
+
+ +
+
+
+ +
+
+
+
+

Commenter le programme avec le while.

+

Que se passe-t-il si on inverse les 2 dernières lignes?

+

Réécrire le programme suivant en utilisant une boucle while et en stockant les antécédents.

+ +
+
+
+
+
+
In [2]:
+
+
+
from math import sin, pi
+
+def h(x):
+    return sin(x*pi/2)
+
+images = []
+antecedants = []
+
+for x in range(20):
+    images.append(h(x))
+    antecedants.append(x)
+
+print("Les images sont ", images)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
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]
+
+
+
+ +
+
+ +
+
+
+
+

Modifier votre programme pour que les antécédents aillent de -2 à 2.

+

Modifier votre programme pour que les antécédents augmentent avec un pas de 0.5 au lieu de 1.

+

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 1.

+

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.5.

+

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.1.

+

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.

+

Astuce: pour tracer 3 graphiques en 1, on fait les plt.plot(...) de chaque graphique et uniquement à la fin on lance plt.show().

+

Comparaison des pas

+ +
+
+
+
+
+
In [ ]:
+
+
+
 
+
+ +
+
+
+ +
+
+
+ + + + + + diff --git a/PreStSauveur/Programmation/5-listes et fonctions.ipynb b/PreStSauveur/Programmation/5-listes et fonctions.ipynb new file mode 100644 index 0000000..587589e --- /dev/null +++ b/PreStSauveur/Programmation/5-listes et fonctions.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Listes et fonctions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graphique de fonctions\n", + "\n", + "Dans cet échauffement, nous allons calculer les images d'une fonction pour tracer sa représentation graphique.\n", + "\n", + "**Recopier** le programme suivant.\n", + "\n", + "**Modifier** la ligne avec le `print` pour faire apparaitre l'image et l'antécédent à chaque ligne.\n", + "\n", + "**Commenter** chaque ligne avec une attention particulière à la ligne qui commence par `for...`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from math import cos, pi\n", + "\n", + "def f(x):\n", + " return cos(x*pi/2)\n", + "\n", + "for x in range(40):\n", + " print(f(x))" + ] + }, + { + "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** ce programme, **commenter** ce programme et retrouver où les listes apparaissent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from math import cos, pi\n", + "\n", + "def f(x):\n", + " return cos(x*pi/2)\n", + "\n", + "images = []\n", + "antecedants = []\n", + "\n", + "for x in range(20):\n", + " images.append(f(x))\n", + "\n", + "print(\"Les images sont \", images)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Modifier** votre programme pour enregistrer aussi les antecedants et les afficher à la fin \n", + "\n", + "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": null, + "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/cos_pas1.png)\n", + "\n", + "Dans un nouveau fichier, **tracer** la courbe représentative de la fonction $g$ tel que\n", + "$$ g : x \\mapsto x^2 - 4$$\n", + "\n", + "![Représentation graphique de f](./fig/g_pas1.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$). 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", + "Ce type de boucle donne plus de contrôle sur $x$ et nous évite d'utiliser `range` qui est une commande qui n'existe que en Python.\n", + "\n", + "Les 2 programmes ci-dessous font la même chose." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for x in range(10):\n", + " print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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", + "for x in range(20):\n", + " images.append(h(x))\n", + " antecedants.append(x)\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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/PreStSauveur/Programmation/5-listes et fonctions_sol.ipynb b/PreStSauveur/Programmation/5-listes et fonctions_sol.ipynb new file mode 100644 index 0000000..0aabde5 --- /dev/null +++ b/PreStSauveur/Programmation/5-listes et fonctions_sol.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from math import cos, pi\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def f(x):\n", + " return cos(x*pi/2)\n", + "\n", + "images = []\n", + "antecedants = []\n", + "\n", + "for x in range(20):\n", + " images.append(f(x))\n", + " antecedants.append(x)\n", + "\n", + "plt.plot(antecedants, images)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from math import sin, pi\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def f(x):\n", + " return sin(x*pi/2)\n", + "\n", + "min_x = -2\n", + "max_x = 2\n", + "\n", + "images = []\n", + "antecedants = []\n", + "\n", + "x = min_x\n", + "while x <= max_x:\n", + " antecedants.append(x)\n", + " images.append(f(x))\n", + " x += 1\n", + "\n", + "plt.plot(antecedants, images)\n", + "\n", + "\n", + "images = []\n", + "antecedants = []\n", + "\n", + "x = min_x\n", + "while x <= max_x:\n", + " antecedants.append(x)\n", + " images.append(f(x))\n", + " x += 0.5\n", + "\n", + "plt.plot(antecedants, images)\n", + "\n", + "\n", + "images = []\n", + "antecedants = []\n", + "\n", + "x = min_x\n", + "while x <= max_x:\n", + " antecedants.append(x)\n", + " images.append(f(x))\n", + " x += 0.1\n", + "\n", + "plt.plot(antecedants, images)\n", + "\n", + "plt.show()" + ] + }, + { + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/PreStSauveur/Programmation/fig/comp_sin.png b/PreStSauveur/Programmation/fig/comp_sin.png new file mode 100644 index 0000000000000000000000000000000000000000..28075a9be9caed808ca1aca866b9ed4940e8b43f GIT binary patch literal 21011 zcmagG1yEg2@HL183GOa=AwV7$B)A3l;O_434#9$l@Njqc;O@cQ-GjT^UVh(xyIcR= zs!bJ1c*UJN(=*+D`kWp@<-UudA`u}$K|!HPhzlz~K|u!t|9?V+2mW^a4toRq^UhIF zLJ1N0o#6~~4Ye>vhEG$lZk{Ve@N~hz^)lK3xMu!KN^UdSgmMI)Re4s(Y z!2kJ!S(xoMeU1E9qwoU(KEoCddGzD@#dEsjX-MC**QskuyP#xf_UEwdWn+UQ7#tCK z$fO7>yofx`4p}i1@bTwcxkv$d9FfKl3l!kHL0%<8IpC*GvWNnJryS5{2;QFYEbPmC z8>4%89_|T$baZsGySsbd82AVR?vEyK2j@9~&9suNP{_#0-oe2UHlqL!F^eGDH!^Nb zmw)>If1UoXz7K(SDu|fWfgEvT9-zQG1w>46AR@NlyKRlz-xwbSU)=^UuHPp7nwHhZ znj5WDrRp#*81eAF0CNJ19^OniHx?8R$R(C+|vPRGNy0Gb~mjc!8vdJc_8Kgqhdpjry)o z$*_+!>bK&5#T!hQqYIiDr@{wNHc&^D{PI1mD(K^I!d6UutZF3y>S>_uL>iJnkU)NpOErMc5N zqRv^BH5^T)h38|$;q-PU25g%-GGd$XY~7;>c?WNrpPFyCmu`M8>cfDY9=!IHd9EgK zYL0dIvZg7>3Jx>)wyWIH~8M|ra1>Oy`!W68V2U&G5^@Jxta1wIOyq5wSBR_ZUZFQ{FKz{g}xJGksQ!_Hk z6_-5zS>!JFlOjGxtvB6g%;V!^`PCEze`S~(-|WW)ha7c zzn4TFmX_i0r3h+6zBzNxQ+ASmh2>ckINgz3K=liZc&8FnVX(5`oNH7tUgx11e2ZD1+73k(&g1h&yuxr&ya%= zAyNukr->!_l2dtst&Nl+j{eoXj2^_)QpX2@iyS>Wn&H$lM(}Qfi|&6RjQt(g_277@ zPT2MvnDvwPvwQo@qZ_A3+*O8-Nt~JCXY)6Iwa?qjy`0#Hp7+qF^|$elxF&vF$MYIQ zoxeiT;_|!ljX9TqUGQNDb*9jmSnl5UpYw7Zl29RS>pD1zGxPMq`lRKDb}G0Os&{dk zbWO-fXce_Q{2NgM>G;^lFrSY5l&`&^((@U}b!v&Zt2oVAMQ zpE8lg`u#x>H^h;lf3KOcXS)2y^m`rk%n`a>?R(0RYkc^JrdE~RcdEGV+v@U?z{m)2 zdKNSUjTPIndaS%ad&K1yO;T#ydgU}ZYiW_ZDug4YDMFK2(3+aql};if#CKufLHP+){u2wfdfs-~j;2*Q5dLC(!V-NmDqR8$gu zMfrOWB}Gba0BoU^u}b&e-_}GazYDI#yN