PY02_Fonctions_Turtle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> <font color=\"red\">Py02 : Modules, fonctions et Tortue avec </font></h1>\n",
    "![logo Python](python-logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">I : Augmenter le vocabulaire et les fonctionnalités de Python - les modules</font></h2>\n",
    "<h3><font color=\"green\">a : Importer un module</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous avons vu dans le notebook précédent que le nombre de mots clé et de fonctions **built-in** de Python est très restreint. Dans le noyau de Python, n'apparaît en fait que les fonctions essentielles à la programmation. Tout peut-être réalisé à partir de ces quelques mots clés.\n",
    "Cependant, et bien heureusement, le programmeur, débutant ou confirmé, n'a pas à tout réinventer. Certaines des fonctionnalités les plus usuelles ont été triées et regroupées au sein de fichiers, voir de dossiers, appelés **modules**. \n",
    "\n",
    "Par défaut, Python ne charge pas en mémoire ces nombreux modules. Il faut donc lui **signifier expressément** le fait de vouloir en charger un, en utilisant le mot clé `import`.\n",
    "\n",
    "Prenons comme exemple les mathématiques. Les fonctions algébriques de base sont incluses dans le noyau Python, mais certaines fonctions comme $\\sqrt{\\phantom{.}}$, $cos$, $sin$, $exp$, $ln$... ne le sont pas.\n",
    "Elles sont donc regroupées au sein du module `math`, qui peut être appelé en mémoire **en début de programme** ( inutile de le faire plusieurs fois...) par :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois ce module chargé, toute les fonctions ( listées [ici](https://docs.python.org/fr/3/library/math.html) ), sont accessibles, **à condition de les appeler en faisant explicitement appel au module __math__**, en utilisant la notation `module.fonction()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(36)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.gcd(75,50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certaines **constantes** peuvent aussi être appelées via le module, avec la syntaxe `module.constante`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4><font color=\"red\">Exercice :</font></h4>\n",
    "\n",
    "Compléter la cellule suivante afin d'afficher les valeurs des sinus et cosinus des angles \n",
    "$\\dfrac{\\pi}{6}$, $\\dfrac{\\pi}{4}$, $\\dfrac{\\pi}{3}$ et $\\dfrac{\\pi}{2}$ radians."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for a in {6,4,3,2} :\n",
    "    #Votre code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <h3><font color=\"green\">b : Simplifier les imports</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Taper dans un programme en permanence `math.sqrt()` devenant très vite très fastidieux, il a été prévu plusieurs solutions pour simplifier cette syntaxe :\n",
    "* si quelques fonctions seulement sont importées, on peu demander à Python de ne charger en mémoire que celles-ci, grâce à la syntaxe `from module import fonction1, fonction2,..`. Les fonctions ainsi importées peuvent ainsi être appelées directement par leur nom :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt, floor,pi\n",
    "\n",
    "print(sqrt(121))\n",
    "print(floor(100*pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* dans certains cas, on peut importer tout le module, mais **c'est une très mauvaise idée**, sauf cas particulier. En effet la mémoire est alors surchargée ( ce qui n'est pas fondamentalement grave), et il y a risque de conflit entre différentes fonctions portant le même nom ( ce qui est plus embêtant...). Dans les rares cas où il est possible de la faire, on utilise la syntaxe `from module import *` ( le symbole `*` en programmation veut parfois dire \"tout\"). Par exemple, en chargeant le module `fractions` dont la documentation est [ici](https://docs.python.org/fr/3/library/fractions.html) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fractions import *\n",
    "print(Fraction(1,2)+Fraction(1,3))\n",
    "print(Fraction(36,24).numerator)\n",
    "print(Fraction(36,24).denominator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* dans tous les cas, il peut être utile de **raccourcir** le nom d'import d'un module, en lui donnant un **alias**, à l'aide de la syntaxe `import module as alias`. Par exemple, avec le module `math` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "print(m.sqrt(100))\n",
    "print(m.degrees(m.pi/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">c : Quelques modules utiles</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien entendu, il existe des centaines de modules, certains déjà intégrés à Python ( `math`, `Fraction`, `sys`,..), d'autres étant développés par des auteurs et/ou consortium indépendants de la fondation Python. Dans ce cas, il faut les télécharger et les importer ( avec l'outil `pip` par exemple), mais ce ne sera pas le cas dans ces cours de terminale...\n",
    "\n",
    "Voici cependant différents module très utiles, sans hiérarchisation aucune :\n",
    "* `turtle` : Un module Turtle pour dessiner dans une fenêtre, apprendre à programmer...\n",
    "* `tkinter` : gérer des fenêtres graphiques ;\n",
    "* `pyQT` : utiliser des fenêtres QT ( prononcer à l'anglaise... comme Cuttie, mignonne quoi...). Nettement plus joli que `tkinter`, mais bigrement plus compliqué...\n",
    "* `random` : utiliser des nombres aléatoires, faire des tirages dans des listes, etc...\n",
    "* `sys` : gérer le système d'exploitation ( connaitre le répertoire courant, créer des fichiers, etc...)\n",
    "* `PIL` : Une bonne bibliothèque de fonctions pour les images ;\n",
    "* `PyGame` : créer des jeux en 2D... Pas mal du tout !\n",
    "* `p2exe` : convertir un fichier python en exécutable windows ;\n",
    "* `NumPy` : Calculs numériques ;\n",
    "* `SciPy` : Calculs scientifiques ;\n",
    "* `Matplotlib` : tracés de courbes et de graphiques divers... Avec les deux derniers, fait partie de la base Python de tout élève des classes préparatoires, ou d'étudiants en sciences...\n",
    "* `Pandas` : gérer et trier de grandes quantités de données ( open data ou IA )\n",
    "* `CherryPy` : Moteur et framework web, on l'utilisera dans une séquence suivante pour créer un site web dynamique...\n",
    "* `Django` : framework web surpuissant...\n",
    "\n",
    "\n",
    "Il y en a bien entnedu de nombreux autres, plus de 20 000 à ce jour, hors créations personnelles...\n",
    "\n",
    "Parce que oui, il est possible et même fortement conseillé de créer ses propres modules, afin d'éviter d'avoir à toujours tout recréer, ou tout réinventer..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">II : Créer ses propres fonctions</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">a : Un exemple - simplifier la saisie utilisateur </font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez probablement remarqué, dans le notebook précédent, qu'il faut souvent demander à l'utilisateur de saisir une valeur... \n",
    "Or l'utilisateur est souvent imprévisible, et si on lui demande de saisir un entier, il peut saisir un nombre flottant, ou pire, une chaîne de caractères, et planter le programme...\n",
    "Pour l'instant, dans nos petits scripts de quelques lignes, ce n'est pas un problème... Mais dès que le script est plus long, ou que son utilisation a une importance décisive, cela peut vite devenir un cauchemar. \n",
    "\n",
    "C'est pourquoi un programme doit toujours être *DUMBPROOF* ( je vous laisse traduire...), en particulier lors d'une saise de valeurs.\n",
    "\n",
    "Imaginons alors un programme où l'utilisateur doit effectuer ue série de  3 relevés de tension ( entre 1 et 5 V), puis d'intensité ( entre 0,1 A et 3 A ), sous forme décimale. Il serait très fastidieux de programmer un tel relevé, en vérifianrt toutes les conditions pour chaque relevé, et en faisant ressaisir à chaque fois l'utilisateur s'il s'est trompé dans sa saisie. Pourtant, fondamentalement, le principe est simple :\n",
    "1. L'utilisateur saisi quelque chose.\n",
    "2. On vérifie que la saisie est du bon type ( float ici ).\n",
    "3. On regarde si la saise n'est pas abérrante ( c'est-à-dire qu'elle est bien entre les bornes ).\n",
    "4. Dans le cas où la saisie est abbérante, on le signale à l'utilisateur et on repart en 1. Sinon on continue.\n",
    "\n",
    "Et bien ce principe peut-être résumé par une **fonction**, qui renverra la valeur saisie par l'utilisateur *uniquement si elle est conforme*, et dont les valeurs de conformité sont passées en **paramètres** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def VerifSaisieFloatBornes(inf,sup):\n",
    "    \"\"\"Fonction demandant une saisie à l'utilisateur, \n",
    "    vérifiant qu'elle est du type float,\n",
    "    et bien comprise de manière large entre les valeurs inf et sup\"\"\"\n",
    "    while True :\n",
    "        n=input(\"Donnez une valeur décimale entre {} et {} : \".format(inf,sup))\n",
    "        try :#Un nouveau mot clé que vous ne connaissez pas :)\n",
    "            n=float(n)\n",
    "            if inf<=n<=sup :\n",
    "                return n\n",
    "            else :\n",
    "                print(\"Cette valeur n'est pas entre {} et {}! Recommencez svp !\".format(inf,sup))\n",
    "        except :#et son frère jumeau\n",
    "            print(\"Je ne peux pas convertir votre valeur en nombre décimal! Recommencez svp !\")\n",
    "            \n",
    "### Fin de la fonction##\n",
    "\n",
    "##Début du programme principal ( les 3 relevés ) :\n",
    "##Vous n'avez pas à comprendre le détail de ce qui est utilisé ici...\n",
    "tensions=[]\n",
    "intensites=[]#ensions et intensites sont des listes\n",
    "for i in range(3) :\n",
    "    tensions.append(VerifSaisieFloatBornes(1,5))\n",
    "    intensites.append(VerifSaisieFloatBornes(0.1,3))\n",
    "for i in range(3) :\n",
    "    print(\"Votre saisie n°{} est : {} V et {} A.\".format(i+1,tensions[i],intensites[i]))\n",
    "    #On affiche à chaque tour de boucle les éléments des listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Fonctions sans retour de valeurs</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fonction sans retour  ( ou  **procédure**), est un bout de code autonome auquel on a donné un nom, et qui pourra être appelé autant de fois que souhaité par son nom :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def table7() :\n",
    "    for i in range(10) :\n",
    "        print(\"7 x {} = {}\".format(i,7*i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En déclenchant la cellule ci-dessus, vous créez un nouveau nom que Python reconnaitra, la fonction `table7()`. cette fonction est alors immédiatement exécutée dès qu'ell est appelée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table7()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table7()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3) :\n",
    "    table7()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction est assez limitée. On aimerait par exemple avoir la possibilité de donner la table de multiplication de n'importe quel nombre plutôt que de limiter celle-ci à la table de 7.\n",
    "\n",
    "Il est possible de créer une telle fonction, dépendant **d'un ou plusieurs paramètres** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def table(n) :\n",
    "    for i in range(10) :\n",
    "        print(\"{} x {} = {}\".format(n,i,n*i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le paramètre est donc `n` qui est donné en argument lors de l'appel à la fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10) :\n",
    "    table(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez dans l'exemple précédent que Python fait bien la différence entre le nom de d'objet `i` **dans** la fonction, et le nom `i` **à l'extérieur** de la fonction..\n",
    "\n",
    "En effet, chaque fonction possède **son propre espace de nom**, les variables ne se chevauchant alors pas.\n",
    "Il existe des mécanismes pour gérér ce qu'on appelle la **portée des variables**, mais ils sont bien au delà du niveau demandé en terminale..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin une dernière remarque, il est possible aussi de passer des **arguments optionnels** à une fonction, mais ces arguments doivent posséder une **valeur par défaut**, et toujours être situés **après les arguments obligatoires**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def table_optimale(n,fin=10) :\n",
    "    for i in range(fin) :\n",
    "        print('{} x {} = {}'.format(n,i,n*i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_optimale(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_optimale(4,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_optimale(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ainsi dans le dernier cas, la fonction est exécutée, mais le paramètre `fin` prend automatiquement la valeur `10`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">c : Fonctions avec retours de valeurs</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imaginons que nous ayons la fonction suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aire_rectangle(long,larg) :\n",
    "    print(long*larg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculons les aires des rectangles suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle(10,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle(12,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle(4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testons alors les égalités suivantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle(10,6)==aire_rectangle(12,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle(4,3)==aire_rectangle(10,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et là nous avons un problème, parce que nous aimerions bien que Python nous dise `False` pour la dernière égalité...\n",
    "\n",
    "Or la fonction `aire_rectangle` n'est pas une vraie fonction... C'est une procédure, et elle ne fait qu'effectuer les lignes de codes de sa définition, c'est à dire écrire à l'écran la chaîne de caractère correspondante,... et c'est tout...\n",
    "\n",
    "Par défaut Python renvoie juste le fait que la fonction a été exécutée, c'est à dire `True`.\n",
    "\n",
    "Cependant, il est possible de transformer une fonction pour qu'elle **retourne** une valeur, ici par exemple l'aire, grâce au mot clé `return` :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aire_rectangle_amelioree(long,larg) :\n",
    "    return long*larg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testons maintenant cette fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle_amelioree(4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle_amelioree(10,6)\n",
    "aire_rectangle_amelioree(12,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous remarquerez qu'une seule valeur `60` est donnée, car **la fonction ne demande pas l'impression du résultat**.\n",
    "Par contre, on peut alors tester les égalités :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle_amelioree(10,5)==aire_rectangle_amelioree(12,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aire_rectangle_amelioree(10,5)==aire_rectangle_amelioree(4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fonction peut donc retourner une ou plusieurs valeurs, selon des schémas précis donnés par les lignes de codes internes, en ayant plusieurs fois le mot clé `return` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Nb_Racines(a,b,c) :\n",
    "    delta=b**2-4*a*c\n",
    "    if delta<0 :\n",
    "        return 0\n",
    "    elif delta==0 :\n",
    "        return 1\n",
    "    else :\n",
    "        return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Nb_Racines(1,2,1))\n",
    "print(Nb_Racines(1,1,-12))\n",
    "print(Nb_Racines(4,3,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou alors, avec plusieurs retours :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Valeurs_Racines(a,b,c) :\n",
    "    from math import sqrt\n",
    "    delta=b**2-4*a*c\n",
    "    if delta>0 :\n",
    "        return (-b-sqrt(delta))/(2*a), (-b+sqrt(delta))/(2*a)\n",
    "    elif delta==0 :\n",
    "        return -b/(2*a)\n",
    "    else :\n",
    "        return None #None est un mot clé de Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Valeurs_Racines(1,2,1))\n",
    "print(Valeurs_Racines(1,1,-12))\n",
    "print(Valeurs_Racines(4,3,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">III : Turtle, un module graphique</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">a : Présentation du module Turtle</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module `turtle` est un module dans lequel on prend le contrôle d'une ou plusieurs tortues, ces tortues pouvant dessiner à l'écran des traits ou des cercles, de différentes couleurs, épaisseurs, etc.\n",
    "\n",
    "Les tortues sont historiquement les pointes de tables traçantes programmables, utilisées pour des patrons ou des tracés de pièces ( mécaniques, tissus, carton, bois...) dans les années 1960 à 1990. Le langage tortue, ou [Logo](https://fr.wikipedia.org/wiki/Logo_(langage)), a été massivement utilisé en France dans les années 1980 en tant que langage d'apprentissage de la programmation (ou de la pensée algorithmique).\n",
    "\n",
    "Les enfants nés dans la seconde partie des années 1970 ont tous connus et programmé des tortues Logo sur les ordinateurs de la marque Thomson ( demandez à vos parents !)\n",
    "\n",
    "Le module `turtle` a donc été implémenté en Python, pour permettre un apprentissage simplifié et ludique de la programmation.\n",
    "\n",
    "Ce module est importable par les méthodes classiques : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "puis utilisable avec des commandes simples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Donatello=turtle.Turtle()\n",
    "for i in range(3) :\n",
    "    Donatello.forward(100)\n",
    "    Donatello.left(120)\n",
    "turtle.mainloop()#à garder pour fermer propremenrt la fenetre Turtle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les commandes sont simples, la documentation du module est complète et claire [ici](https://docs.python.org/fr/3/library/turtle.html). Mais voici quelques exemples de commande :\n",
    "* `reset()` : On efface tout et on recommence ;\n",
    "* `goto(x,y)` : Aller à l’endroit de coordonnées x et y ;\n",
    "* `forward(distance)` : Avancer d’une distance donnée ;\n",
    "* `backward(distance)` : Reculer ;\n",
    "* `up()` : Relever le crayon (pour pouvoir avancer sans dessiner) ;\n",
    "* `down()` Abaisser le crayon (pour pouvoir recommencer à dessiner) ;\n",
    "* `color(couleur)` : Couleur peut être une chaîne prédéfinie (’red’, ’blue’, ’green’, etc.) ;\n",
    "* `left(angle)` : Tourner à gauche d’un angle donné (exprimé en degré) ;\n",
    "* `right(angle)` : Tourner à droite ;\n",
    "* `width(épaisseur)` : Choisir l’épaisseur du tracé ;\n",
    "* `begin_fill()` et `end_fill()` : Remplir un contour fermé (entre ces deux instructions) à l’aide de\n",
    "la couleur sélectionnée ;\n",
    "* `write(texte)` : texte doit être une chaîne de caractères délimitée avec des ” ou des ’.\n",
    "\n",
    "Ainsi les lignes suivantes créé une tortue du nom de Franklin, de couleur violette, et traçant un segment de 100 pixels :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Franklin=turtle.Turtle()\n",
    "Franklin.color('green')\n",
    "Franklin.forward(100)\n",
    "turtle.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Quelques exercices</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Tracer la figure ci-contre : ![Maison Logo](C02_02_maison.png)\n",
    "2. Écrire un code permettant de tracer un rectangle de dimension donnée.\n",
    "3. Compléter le code pŕécédent afin que le rectangle ait aussi une orientation souhaitée (qu’il puisse être sur la pointe).\n",
    "4. Créer une fonction à partir de ce code, puis tracer un carré de côté donné. \n",
    "5. Tracer avec Turtle un triangle équilatéral plein, de couleur rouge, et de taille 100.\n",
    "6. Tracer avec Turtle un triangle équilatéral plein, de couleur bleue, et de taille 50.\n",
    "7. Tracer avec Turtle un triangle équilatéral plein, de couleur verte, et de taille 100, et « sur la pointe ».\n",
    "8. Utiliser les questions précédentes pour créer une étoile à 6 branches de couleur jaune.\n",
    "9. Créer une fonction `Triangle_equi(posx,posy,taille=100,couleur='jaune')` permettant de créer différents triangles équilatéraux de différentes couleurs, tailles et orientations, et dont les coordonnées du centre sont `(posx; posy)`.\n",
    "10. Créer une fonction `Star((posx,posy,taille=100,couleur='jaune')` permettant de créer différentes étoiles, de différentes couleurs, tailles et orientations, et dont les coordonnées du centre sont `(posx; posy)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">c : Un Mini-projet Halloween</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le projet est de créer une image de type Halloween, respectant les conditions suivantes :\n",
    "* respect de l'organisation du code :\n",
    "    1. imports de modules ;\n",
    "    2. fonctions ;\n",
    "    3. Code principal ;\n",
    "* présence d'une lune rousse, complète ou non ;\n",
    "* présence d'étoiles dans le ciel d'étoiles, chaque étoile étant créés par une fonction dont les paramètres seront le point de départ et la taille ;\n",
    "* présence d'un ou pluseiurs Jack'O Lantern ( avec un bonus s'ils sont créés grâce à une fonction dépendant d'un paramètre taille)."
   ]
  }
 ],
 "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
}