{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Préambule " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ce fichier (s'il porte l'extension `.ipynb`) est un notebook Python.\n", "\n", "Il comporte deux types de cellules :\n", "\n", "* les cellules d'édition dans lesquelles vous pouvez saisir du texte éventuellement enrichi de mises en formes ou de liens hypertextes avec la syntaxe du langage HTML simplifié qui s'appelle Markdown. Voir http://daringfireball.net/projects/markdown/ pour la syntaxe de Markdown.\n", "\n", "* les cellules de code où l'on peut saisir du code Python3 puis le faire exécuter avec la combinaison de touches `CTRL + RETURN`\n", "\n", "Une cellule peut être éditée de deux façons différentes :\n", "\n", "* en mode _commande_ lorsqu'on clique sur sa marge gauche qui est surlignée alors en bleu, on peut alors :\n", "\n", " - changer le type de la cellule en appuyant sur `m` pour passer en cellule Markdown ou sur `y` pour passer en cellule de code\n", " \n", " - insérer une cellule juste au-dessus en appuyant sur `a`\n", " \n", " - insérer une cellule juste en-dessous en appuyant sur `b`\n", " \n", " - couper la cellule en appuyant sur `x` etc ...\n", " \n", "* en mode _édition_ lorsqu'on clique sur l'intérieur de la cellule.\n", "\n", "L'aide complète sur les raccourcis claviers est accessible depuis le bouton `Help` dans la barre d'outils ci-dessus.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Utiliser le mode interactif" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "1. Écrire les expressions suivantes avec un parenthésage explicite permettant d'indiquer l'ordre de priorité des opérations :\n", "\n", "~~~python\n", ">>> 2 - 3 - 4 \n", "-5\n", ">>> 1 / 2 ** 3\n", "0.125\n", ">>> 1/ 2 / 4\n", "0.125\n", ">>> 1/ 2 * 4\n", "2.0\n", ">>> 2 * 3 ** 2\n", "18\n", ">>> 2 ** 3 ** 2\n", "512\n", ">>> 34 // 3 % 4 \n", "3\n", ">>> 5 % 3 ** 4\n", "5\n", "~~~\n", "\n", "avec parenthésage :\n", "\n", "~~~python\n", ">>> (2 - 3) - 4 \n", "-5\n", ">>> 1 / (2 ** 3)\n", "0.125\n", ">>> (1/ 2) / 4\n", "0.125\n", ">>> (1/ 2) * 4\n", "2.0\n", ">>> 2 * (3 ** 2)\n", "18\n", ">>> 2 ** (3 ** 2)\n", "512\n", ">>> (34 // 3) % 4 \n", "3\n", ">>> 5 % (3 ** 4)\n", "5\n", "~~~\n", "\n", "2. Écrire les expressions suivantes avec le moins de parenthèses possibles :\n", "\n", "~~~python\n", ">>> 2 + (8 * (4 - 5))\n", ">>> (3 - 5) - ((6 * 2) / (5 ** 2)) \n", "~~~\n", "\n", "avec moins de parenthèses :\n", "\n", "~~~python\n", ">>> 2 + 8 * (4 - 5)\n", ">>> 3 - 5 - 6 * 2 / 5 ** 2\n", "~~~" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice 2\n", "\n", "
\n", " \n", "Prédire la valeur affichée dans l'interprète Python après les séquences d'instructions suivantes.\n", "\n", "1. Séquence 1 :\n", "\n", "~~~python\n", ">>> a = 5\n", ">>> a = a + 1\n", ">>> b = a\n", ">>> b = b ** 2 - a\n", ">>> print(b)\n", "~~~\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "30\n" ] } ], "source": [ "a = 5\n", "a = a + 1\n", "b = a\n", "b = b ** 2 - a\n", "print(b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "2. Séquence 2 :\n", "\n", "~~~python\n", ">>> a = 5\n", ">>> b = 6\n", ">>> a = a - b\n", ">>> b = b + a\n", ">>> a = b - a\n", ">>> print(a, b)\n", "~~~\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "6 5\n" ] } ], "source": [ "a = 5\n", "b = 6\n", "a = a - b\n", "b = b + a\n", "a = b - a\n", "print(a, b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "3. Séquence 3 :\n", "\n", "~~~python\n", ">>> from random import randint\n", ">>> a = randint(1, 100) #entier aléatoire entre 1 et 100\n", ">>> b = randint(1, 100) #entier aléatoire entre 1 et 100\n", ">>> a = a - b\n", ">>> b = b + a\n", ">>> a = b - a\n", ">>> print(a, b)\n", "~~~" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "41 30\n" ] } ], "source": [ "from random import randint\n", "a = randint(1, 100) #entier aléatoire entre 1 et 100\n", "b = randint(1, 100) #entier aléatoire entre 1 et 100\n", "a = a - b\n", "b = b + a\n", "a = b - a\n", "print(a, b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Premiers programmes et premières erreurs\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice 3\n", "\n", "
\n", " \n", "1. Dans son espace personnel, créer un répertoire `Chapitre1` avec un sous-répertoire `TP1`.\n", "2. Le prix d'une matière première est de 873 euros la tonne au début de l'année. Ce prix subit des variations saisonnières : au premier trimestre il augmente de 347 euros, au second trimestre il augmente de 25 %, au troisième trimestre il subit une baisse de 50 % et enfin il diminue de 100 euros.\n", "\n", " * Créer un nouveau programme avec l'éditeur d'Idle et l'enregistrer dans `Chapitre1/TP1` sous le nom `prix.py`.\n", "\n", " * Saisir dans ce fichier le code ci-dessous en le complétant afin qu'il calcule les valeurs successives de la variable `prix`. \n", "\n", "~~~python\n", "prix = 873 #prix au début de l'année\n", "prix = .... #prix à la fin du premier trimestre\n", "prix = .... #prix à la fin du second trimestre\n", "prix = .... #prix à la fin du troisième trimestre\n", "prix = .... #prix à la fin de l'année\n", "print(\"Prix final :\", prix)\n", "~~~" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Prix final : 662.5\n" ] } ], "source": [ "prix = 873 #prix au début de l'année\n", "prix = prix + 347 #prix à la fin du premier trimestre\n", "prix = prix * 1.25 #prix à la fin du second trimestre\n", "prix = prix * 0.5 #prix à la fin du troisième trimestre\n", "prix = prix - 100 #prix à la fin de l'année\n", "print(\"Prix final :\", prix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice 4\n", "\n", "
\n", " \n", "La température $f$ en degrés Fahrenheit s'obtient à partir de la température $c$ en degrés Celsius par la formule de conversion $f=1,8 * c + 32$. \n", "\n", "On veut écrire un programme qui réponde à la __spécification__ suivante : _convertir une mesure de température de l'échelle Celsius vers l'échelle Fahrenheit._\n", "\n", "1. Dans l'éditeur d'Idle, créer un programme `temperature.py` et saisir le code ci-dessous :\n", "\n", "~~~python\n", "f = input(\"Température en degrés Celsius ? \"\n", "d = 1,8 * f + 32\n", "print(\"La température en degrés Fahrenheit est de \", d)\n", "~~~\n", "\n", "2. Exécuter le code, on doit obtenir un message d'erreur indiquant une erreur de Syntaxe. Un curseur indique dans le code la position où l'interpréteur [Python][Python] s'est interrompu dans la lecture du code. Si le curseur est en début de ligne, il faut souvent chercher l'erreur à la fin de la ligne précédente ...\n", "\n", " Corriger l'erreur de syntaxe." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "__Corrigé__ : la première erreur est une erreur de syntaxe est l'oubli de la fermeture de la parenthèse de la fonction `input `." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 2)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m d = 1,8 * f + 32\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "f = input(\"Température en degrés Celsius ? \"\n", "d = 1,8 * f + 32\n", "print(\"La température en degrés Fahrenheit est de \", d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "__Corrigé__ : la seconde erreur est une erreur de type : on ne peut pas additionner la valeur de `f` qui est de stype `str` (car renvoyée par `input`) et 32 de type `int`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = input(\"Température en degrés Celsius ? \")\n", "print(type(f))\n", "d = 1,8 * f + 32\n", "print(\"La température en degrés Fahrenheit est de \", d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "5. Remplacer la première instruction par `float(input(\"Température en degrés Celsius ? \"))` puis exécuter. \n", "\n", " Quel est l'effet de la fonction `float` ? Afficher sa documentation dans l'interpréteur avec l'instruction `help(float)`. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "__Corrigé__ : la troisième erreur est plus subtile : Python retourne un `tuple` car on a utilisé la virgule au lieu du point comme séparateur décimal." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = float(input(\"Température en degrés Celsius ? \"))\n", "print(type(f))\n", "d = 1,8 * f + 32\n", "print(\"La température en degrés Fahrenheit est de \", d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " \n", "__Corrigé__ : une version correcte du code : " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Température en degrés Celsisus ? 44\n", "La température en degrés Fahrenheit est de 111.2\n" ] } ], "source": [ "f = float(input(\"Température en degrés Celsisus ? \"))\n", "d = 1.8 * f + 32\n", "print(\"La température en degrés Fahrenheit est de \", d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Effets de bord et erreur" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice 5\n", "\n", "
\n", "\n", "\n", " \n", "On veut écrire un programme vérifiant la __spécification__ suivant : _le programme doit permuter les valeurs de deux variables `a` et `b` de type entier saisies en entrée_.\n", "\n", "Avec l'éditeur Idle, créer dans le répertoire `TP1` un nouveau programme `permutation.py` et recopier le code ci-dessous\n", "\n", "~~~python\n", "# entrées\n", "a = int(input('a ?'))\n", "b = int(input('b ?'))\n", "# traitement\n", "a = b\n", "b = a \n", "# sorties\n", "print(\"a = \", a, \" et b = \", b)\n", "~~~\n", "\n", "1. Tester ce programme pour les entrées 605 et 506. La spécification du programme est-elle satisfaite ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# entrées\n", "a = int(input('a ?'))\n", "b = int(input('b ?'))\n", "# traitement\n", "a = b\n", "b = a \n", "# sorties\n", "print(\"a = \", a, \" et b = \", b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "Le programme ne permute pas les valeurs des variables `a` et `b`, il affecte la valeur initiale de `a` à `a` puis à `b`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "\n", "2. Pour représenter l'exécution du programme, compléter le tableau d'état ci-dessous, qui affiche pour chaque ligne d'instruction, les valeurs des variables `a` et `b` et les éventuelles interactions avec l'utilisateur. \n", "\n", "| Ligne | Variable a | Variable b | Interactions |\n", "|----------------------------------------------------------|------------|------------|--------------|\n", "| a = int ( input ( 'a ?' )) | 734 | | __affichage :__ 'a ?' __saisie__ : 734 |\n", "| b = int ( input ( 'b ?' )) | 734 | 437 | __affichage :__ 'b ?' __saisie :__ 437 |\n", "| a = b | 437 | 437 | |\n", "| b = a | 437 | 437 | |\n", "| print ( \"a = \" , a, \" et b = \" , b) | | | __affichage :__ a = 437 et b = 437 |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "3. Proposer une modification du programme qui permute les valeurs des variables `a` et `b` saisies en entrée.\n", " \n", " Démontrer que le programme est correct en complétant un tableau d'état de ce nouveau programme qui utilise des valeurs indéterminées `x` et `y` pour les variables `a` et `b` en entrée. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "On peut utiliser une variable supplémentaire pour stocker la valeur initiale de `a`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# entrées\n", "a = int(input('a ?'))\n", "b = int(input('b ?'))\n", "# traitement\n", "c = a \n", "a = b\n", "b = c\n", "# sorties\n", "print(\"a = \", a, \" et b = \", b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "\n", "4. Proposer une modification du programme qui permute les valeurs des variables `a` et `b` saisies en entrée, sans utiliser de variable supplémentaire." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "Permutation de variables, sans utiliser une variable supplémentaire pour stocker la valeur initiale de `a`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# entrées\n", "a = int(input('a ?'))\n", "b = int(input('b ?'))\n", "# traitement\n", "a = a + b\n", "b = a - b\n", "a = a - b\n", "# sorties\n", "print(\"a = \", a, \" et b = \", b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "| Ligne | Variable a | Variable b | Interactions |\n", "|----------------------------------------------------------|------------|------------|--------------|\n", "| a = int ( input ( 'a ?' )) | x | | __affichage :__ 'a ?' __saisie__ : x |\n", "| b = int ( input ( 'b ?' )) | x | y | __affichage :__ 'b ?' __saisie :__ y |\n", "| a = a + b | x + y | y | |\n", "| b = a - b | x + y | x | |\n", "| a = a - b | y | x | |\n", "| print ( \"a = \" , a, \" et b = \" , b) | | | __affichage :__ a = y et b = x |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Utiliser une bibliothèque" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from turtle import *" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from ipyturtle import Turtle" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "help(circle)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Tous les code suivantes pourront être écrits dans répétition de bloc d'instruction avec la structure de boucle." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Exercice 6\n", "\n", "
\n", "\n", "1. Avec l'éditeur d'Idle, créer dans le répertoire `TP1` un nouveau programme `tortue-polygones.py` et importer toutes les fonctions du module `turtle` avec `from turtle import *`.\n", "2. Écrire un programme qui trace un carré de côté 100 pixels en utilisant les instructions `forward` et `left`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from turtle import *\n", "up()\n", "goto(0,0)\n", "down()\n", "forward(100)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "exitonclick()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "2. Écrire un programme qui trace un triangle équilatéral de côté 100 pixels.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from turtle import *\n", "up()\n", "goto(0,0)\n", "down()\n", "forward(100)\n", "left(120)\n", "forward(100)\n", "left(120)\n", "forward(100)\n", "left(120)\n", "exitonclick()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "3. Écrire un programme qui trace un hexagone régulier de côté 100 pixels." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from turtle import *\n", "angle = 360 / 6\n", "up()\n", "goto(0,0)\n", "down()\n", "forward(100)\n", "left(angle)\n", "forward(100)\n", "left(angle)\n", "forward(100)\n", "left(angle)\n", "forward(100)\n", "left(angle)\n", "forward(100)\n", "left(angle)\n", "forward(100)\n", "left(angle)\n", "exitonclick()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Exercice 7\n", "\n", "
\n", "\n", "1. Avec l'éditeur d'Idle, créer dans le répertoire `TP1` un nouveau programme `tortue-clef.py` et importer toutes les fonctions du module `turtle` avec `from turtle import *`.\n", "2. Exécuter puis dans le du mode interactif la documentation de l'instruction `circle` avec `help(circle)`.\n", "3. Saisir dans le programme la séquence d'instructions suivante, exécuter puis observer.\n", "\n", "~~~python\n", "from turtle import *\n", "forward(60)\n", "left(120)\n", "forward(60)\n", "right(90)\n", "circle(60,150)\n", "exitonclick() \n", "~~~ \n", "\n", "1. Compléter le programme pour afficher une figure en forme de clef. \n", " " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from turtle import *\n", "forward(60)\n", "left(120)\n", "forward(60)\n", "right(90)\n", "circle(60,300)\n", "right(90)\n", "forward(60)\n", "left(120)\n", "forward(60)\n", "right(90)\n", "exitonclick() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Exercice 8\n", "\n", "
\n", "\n", "1. Avec l'éditeur d'Idle, créer dans le répertoire `TP1` un nouveau programme `tortue-triangles.py`.\n", "2. Le programme ci-dessous permet de tracer un triangle équilatéral noir de côté 100 pixels. Compléter le code pour tracer la figure de droite avec la pyramide de triangles." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "begin_fill()\n", "fillcolor(\"black\")\n", "forward(100)\n", "left(120)\n", "forward(100)\n", "left(120)\n", "forward(100)\n", "left(120)\n", "end_fill()\n", "fillcolor(\"white\")\n", "forward(50)\n", "begin_fill()\n", "left(60)\n", "forward(50)\n", "left(120)\n", "forward(50)\n", "left(120)\n", "forward(50)\n", "left(120)\n", "end_fill()\n", "exitonclick()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Exercice 8\n", "\n", "
\n", "\n", "1. Avec l'éditeur d'Idle, créer dans le répertoire `TP1` un nouveau programme `tortue-drapeau.py`.\n", "2. Écrire un programme qui dessine le drapeau français." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "begin_fill()\n", "up()\n", "goto(-100,0)\n", "down()\n", "fillcolor(\"blue\")\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "end_fill()\n", "up()\n", "down()\n", "forward(100)\n", "begin_fill()\n", "fillcolor(\"white\")\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "end_fill()\n", "up()\n", "down()\n", "forward(100)\n", "begin_fill()\n", "fillcolor(\"red\")\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "forward(100)\n", "left(90)\n", "forward(200)\n", "left(90)\n", "end_fill()\n", "exitonclick()" ] } ], "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": 4 }