Intro5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=right> <font color='darkblue'>Une petite introduction à Python [5/5]</font></div>\n",
    "\n",
    "----\n",
    "\n",
    "\n",
    "# <font color=darkred> &#10070; Les fonctions </font>\n",
    "## <font color=darkblue> &diams; Premier exemple de fonction </font>\n",
    "\n",
    "Avant de définir nos propres fonctions, découvrons ensemble quelques exemples de fonctions existantes déjà dans Python pour en comprendre le fonctionnement. \n",
    "\n",
    "**Exécuter** le programme ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taper un mot : toujours\n",
      "ce mot contient  8  lettres\n"
     ]
    }
   ],
   "source": [
    "mot = input(\"Taper un mot : \")\n",
    "nb_lettres = len(mot)\n",
    "print(\"ce mot contient \",nb_lettres,\" lettres\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous venons d'utiliser la **fonction** `len` qui prend comme **argument** une chaîne de caractère et **retourne** la longueur de cette chaîne de caractères. D'ailleurs `len` est l'abbréviation de `length`, longueur en anglais.\n",
    "\n",
    "Une fonction prend donc en entrée un ou plusieurs arguments, effectue un traitement sur ces arguments et **retourne** une valeur. La valeur retournée par la fonction pourra être affectée à une variable comme nous l'avons fait ci-dessus avec l'instruction : <code>nb_lettres = <b>len</b>(mot)</code>.\n",
    "\n",
    "Cela vous rappelle sans doute l'écriture $y=f(x)$ rencontrée en mathématiques où $f$ désigne la fonction, $x$ son argument et $y$ l'image de $x$. Et bien évidemment, Python inclus de nombreuses fonctions mathématiques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; Une fonction mathématique </font>\n",
    "\n",
    "Python est un langage *modulaire* ce qui signifie qu'on peut lui ajouter des fonctionnalités qui ne sont pas forcément présentes dès le départ. C'est le cas des fonctions mathématiques qu'il faudra **importer** avant de pouvoir les utiliser. Par exemple l'instruction suivante importe la fonction mathématique **sqrt** qui se trouve dans le module **math**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dispose maintenant d'une nouvelle fonction <code>sqrt</code>, que l'on peut tester :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "print(sqrt(25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n"
     ]
    }
   ],
   "source": [
    "print(sqrt(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "print(sqrt(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces trois exemples ont du vous permettre de reconnaître la fonction *racine carrée*, en effet **sqrt** est l'abréviation de *square root* c'est à dire racine carré en anglais. La fonction `sqrt` ci-dessus est donc en quelque sorte l'équivalent de la fonction : <br>\n",
    "$x \\mapsto \\sqrt{x}$ que vous avez rencontré en mathématiques. <br>\n",
    "Le calcul suivant nous montre que `sqrt(2)**2` ne donne pas exactement 2 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "print(sqrt(2)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alors qu'en mathématiques, vous avez vu que $\\left(\\sqrt{2}\\right)^2=2$. Cela est du aux erreurs d'arrondi toujours présentes lorsque l'on calcule sur un ordinateur et dont il faut être conscient.\n",
    "\n",
    "\n",
    "La fonction `sqrt` prend comme argument un nombre en virgule flottant (`float`) et retourne sa racine carrée. Remarquez la similitude avec  `len` vue ci-dessous qui prend comme un argument une chaine de caractère (`str`) et retourne sa longueur. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; Notre première fonction </font>\n",
    "\n",
    "Rappelons que le périmètre $P$ d'un rectangle, est donné par la formule :<br>\n",
    "$P=2\\,(L+l)$<br>\n",
    "où $L$ est la longueur du rectangle et $l$ sa largeur.\n",
    "\n",
    "Nous pouvons **définir** une fonction en Python qui fera ce calcul, il nous faut lui donner un nom (comme `len` ou `sqrt` vues plus haut), préciser ses arguments et définir la valeur qu'elle **retourne**. Nous choisisson comme nom `perimetre` nous nommerons les arguments `long` et `larg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perimetre(long,larg):\n",
    "    peri=2*(long+larg)\n",
    "    return peri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observons comme d'habitude la syntaxe du langage,  on commence par écrire l'instruction `def` suivi du nom de la fonction (que nous sommes libres de choisir), suivent  entre parenthèses les arguments de la fonction (ici `long` et `larg`) suivi du désormais traditionnel caractère `:`\n",
    "\n",
    "Après avoir effectué le calcul, la fonction retourne son résultat grâce à l'instruction `return`.\n",
    "\n",
    "Vous remarquez que l'exécution de la cellule ci-dessus n'a fourni aucun résultat, mais nous disposons maintenant d'une nouvelle fonction : `perimetre` que nous pouvons utiliser tout comme nous avions utilisé `len` ou `sqrt` plus haut.\n",
    "\n",
    "*Exécuter* les cellules suivantes pour tester notre fonction `perimetre`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "print(perimetre(3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "print(perimetre(10,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>&#9889; A retenir : </b><ul>\n",
    "    <li> L'instruction <code><b> def</b></code> permet de définir une fonction\n",
    "    <li> elle est suivie du nom de la fonction et des arguments entre parenthèses et du caractère <code>:</code>\n",
    "    <li> Les instructions qui suivent sont <b>indentées</b>(de même que pour les boucles ou les instructions conditionneles vues auparavant)\n",
    "    <li> L'instruction <code><b> return </b></code> permet de retourner le résultat de la fonction \n",
    "    </ul> </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "1. <font color='green'> Un radar pédagogique est mis en place sur une route limitée à 80 km/h, lorsque la vitesse du véhicule est en dessous de cette limite, le message 'Bonne route' s'affiche dans le cas contraire le message 'Réduisez votre vitesse' s'affiche. **Compléter** la définition de la fonction Python ci-dessous qui retourne le message à afficher en fonction de la vitesse.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction message en fonction de la vitesse\n",
    "___ message_radar(vitesse):\n",
    "    if ______<=80:\n",
    "        message='Bonne _____'\n",
    "    ____:\n",
    "        message='_____________________'\n",
    "    ______ message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. <font color='green'> <b>Tester</b> votre fonction pour diverses valeurs de la vitesse </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests de la fonction - changer la valeur de l'argument\n",
    "print(message_radar(60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. <font color='green'> Le degré <a href='https://fr.wikipedia.org/wiki/Degr%C3%A9_Fahrenheit'>Fahrenheit</a> est une unité de mesure de température encore utilisée dans certains pays. On peut convertir une température exprimée en degré Celsius $C$ en degré Fahrenheit $F$ en utilisant la formule :<br>\n",
    "$F = \\dfrac{9}{5} C + 32$ <br>\n",
    "<b>Ecrire</b> une fonction Python qui effectue cette conversion.\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction de conversion Celsius > Fahrenheit\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. <font color='green'> <b>Ecrire</b> une fonction <code>moyenne</code> qui prend comme paramètre 3 nombres et renvoie leur moyenne. Tester votre fonction pour diverses valeurs des paramètres. </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition et test de la fonction moyenne de 3 nombres\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. <font color='green'> <b>Ecrire</b> une fonction <code>nb_secondes</code> qui prend comme paramètre les trois valeurs  heures, minutes et secondes d'un horaire et retourne le nombre total de secondes de cet horaire. </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction calculant le nombre de secondes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; De l'intérêt des fonctions </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons supposer ici que notre but ici est d'écrire une fonction qui encadre un texte passé en paramètre.\n",
    "Par exemple : <br>\n",
    "`print(encadre('Python'))` <br>\n",
    "Devra afficher : <br>\n",
    "```\n",
    "##########\n",
    "# Python #\n",
    "##########\n",
    "```\n",
    "Le nombre de caractères à afficher sur la première ligne dépend de la longueur du mot à encadrer, et nous avons vu au début de ce notebook que nous pouvons utiliser `len` pour récupérer cette longueur. Rappelons que pour répéter un caractère il suffit d'utiliser le symbole `*` et que le caractère `\\n` dans une chaine de caractères permet de passer à la ligne.\n",
    "\n",
    "Après avoir lu **attentivement** ces rappels vous devriez comprendre aisément les instructions ci-dessous, si besoin en vous aidant des commentaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction permettant d'encadrer un texte passé en paramètre\n",
    "def encadre(texte):\n",
    "    #le nombre total de # sur la première ligne = longueur du mot + 2 (pour les espaces) + 2 (pour les #)\n",
    "    longueur=len(texte)+4 \n",
    "    #la variable texte_enc contiendra le texte encadré, on commence par y mettre les # de la première ligne\n",
    "    texte_enc='#'*longueur \n",
    "    texte_enc=texte_enc+'\\n' # pour passer à la ligne on utilise le \\n\n",
    "    texte_enc=texte_enc+'# '+texte+' #'+'\\n' #la ligne du milieu qui contient le texte entre '# ' et ' #'\n",
    "    texte_enc=texte_enc+'#'*longueur #la ligne finale\n",
    "    return texte_enc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "##########\n",
      "# Python #\n",
      "##########\n"
     ]
    }
   ],
   "source": [
    "print(encadre('Python'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "###########################\n",
      "# Vive la programmation ! #\n",
      "###########################\n"
     ]
    }
   ],
   "source": [
    "print(encadre('Vive la programmation !'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous comprenez ici, l'un des intérêts des fonctions : nous pouvons utiliser autant de fois notre fonction d'encadrement sans avoir à la réecrire. En modifiant légèrement notre fonction nous pouvons même l'adapter à d'autres situations :\n",
    "\n",
    "## <font color=green> &#9998; Exercices </font>\n",
    "5. <font color='green'> Recopier puis **modifier** la fonction encadre ci-dessous en la renommant `encadre2`, elle prendra en plus du texte un seconde paramètre qui sera utilisé à la place du #.<br>\n",
    "Par exemple,<br>\n",
    "`print(encadre2('Python',':'))` <br>\n",
    "Devra afficher : <br>\n",
    "```\n",
    "::::::::::\n",
    ": Python :\n",
    "::::::::::\n",
    "```\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction encadre à recopier ici puis à modifier\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=darkblue> &diams; Décomposer un problème en sous-problèmes plus simples </font>\n",
    "\n",
    "Les fonctions sont aussi un bon moyen d'appliquer une stratégie bien connue pour résoudre des problèmes complexes : les **décomposer** en sous-problèmes plus simples à résoudre.\n",
    "\n",
    "Pour illustrer notre propos, nous allons prendre un exemple et écrire notre premier jeu en python : pierre, feuille, ciseaux. Le programme demandera à l'utilisateur de choisir l'une des trois possibilités, puis choisira lui-même au hasard et enfin donnera le résultat de la partie. Nous pouvons donc *décomposer* notre programme en 3 fonctions :\n",
    "* `choix_joueur()` qui ne prend aucun paramètre et retourne le choix du joueur \n",
    "* `choix_ordi()` qui ne prend aucun paramètre et retourne le choix de l'ordinateur\n",
    "* `resultat(joueur,ordi)` qui prend comme paramètre les deux choix précédents et retourne le résultat de la partie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction qui renvoie le choix du joueur\n",
    "def choix_joueur():\n",
    "    choix=input(\"Choisissez : (P)ierre, (F)euille ou (C)iseaux \")\n",
    "    return choix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour le choix de l'ordinateur nous allons utiliser une fonction permettant de générér un entier au hasard, cette fonction s'appelle `randint` et se trouve dans le module `random`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction s'utilise en spécifiant entre parenthèses la valeur minimale et maximale de l'entier que l'on tire au sort. Ici trois choix sont possibles, nous allons donc tirer au sort entre 1 et 3 et associer le 1 à Pierre, le 2 à Feuille et le 3 à Ciseaux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction qui renvoie le choix de l'ordinateur, tiré au sort grâce à randint\n",
    "def choix_ordi():\n",
    "    numero=randint(1,3)\n",
    "    if numero==1:\n",
    "        choix='P'\n",
    "    if numero==2:\n",
    "        choix='F'\n",
    "    if numero==3:\n",
    "        choix='C'\n",
    "    return choix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "teste choix ordinateur n° 1 : F\n",
      "teste choix ordinateur n° 2 : C\n",
      "teste choix ordinateur n° 3 : F\n",
      "teste choix ordinateur n° 4 : C\n",
      "teste choix ordinateur n° 5 : P\n"
     ]
    }
   ],
   "source": [
    "# Testons en faisant choisir l'ordinateur au hasard 5 fois (cela nous permet de réviser la boucle for !)\n",
    "for essai in range(1,6):\n",
    "    print(\"teste choix ordinateur n°\",essai,\":\",choix_ordi())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela semble fonctionner ! Il nous reste simplement à comparer les résultats et à retourner une phrase indiquant le vainqueur de la partie !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction qui décide du résultat de la partie en fonction du choix joueur et ordi\n",
    "def resultat(joueur,ordi):\n",
    "    # Si même choix pour les deux, la partie est nulle\n",
    "    if joueur == ordi:\n",
    "        result='Partie nulle !'\n",
    "    # Si les choix sont différents on traite le cas ou le joueur gagne \n",
    "    else:\n",
    "        if (joueur=='P' and ordi=='C') or (joueur=='F' and ordi=='P') or (joueur=='C' and ordi=='F'):\n",
    "            result='Vous avez gagné !'\n",
    "        else:\n",
    "            result='Vous avez perdu !'\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sur cet exemple, nous utilisons les **connecteurs logiques** déjà rencontrés auparavant qui permettent d'associer plusieurs conditions, comme vous avez pu le comprendre `and` correspond au **et** et `or` au **ou**. Par exemple `(joueur=='P' and ordi='C')` signifie que le joueur a joué pierre et l'ordinateur ciseaux.\n",
    "\n",
    "Il nous reste à faire un programme Python utilisant ces trois fonctions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choisissez : (P)ierre, (F)euille ou (C)iseaux P\n",
      "Joueur :  P\n",
      "Ordinateur :  C\n",
      "Vous avez gagné !\n"
     ]
    }
   ],
   "source": [
    "# Jeu de pierre feuille ciseaux :\n",
    "joueur = choix_joueur()\n",
    "print('Joueur : ',joueur)\n",
    "ordi = choix_ordi()\n",
    "print('Ordinateur : ',ordi)\n",
    "print(resultat(joueur,ordi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A titre d'exercice, nous vous proposons d'apporter quelques améliorations à ce premier jeu :\n",
    "\n",
    "## <font color=green> &#9998; Exercices </font>\n",
    "6. <font color='green'>Modifier La fonction `choix_joueur` afin qu'elle n'accepte que les choix P, F ou C. Si le joueur entre autre chose, le programme lui repose la question</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction choix joueur version 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. <font color='green'> Modifier le programme principal pour qu'en la fin d'une partie, on offre au joueur la possibilité de rejouer </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nouvelle version avec possibilité de rejouer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. <font color='green'> Modifier encore votre programme de façon à comptabiliser le nombre de victoires du joueur et de l'ordinateur. Faire afficher en fin de partie le score. </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Version avec possibilité de rejouer et comptage des points\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez compris que cet exemple fait en quelque sorte la synthèse de ce que nous avons vu jusqu'ici en Python :\n",
    "* les affichages avec print et les affectations de variables\n",
    "* les input et les types de variables\n",
    "* les instructions conditionnelles\n",
    "* les boucles\n",
    "* les fonctions\n",
    "\n",
    "En cas de problèmes n'hésitez pas à revenir sur l'un de ces notebooks.\n",
    "\n",
    "Avant de vous laisser avec quelques exercices, notons la présence dans Python d'une aide intégrée, affichable avec l'instruction `help`, par exemple nous avons utilisé plus haut la fonction `randint` de la bibliothèque `random`. Pour obtenir des explications sur l'utilisation de cette fonction on tape simplement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method randint in module random:\n",
      "\n",
      "randint(a, b) method of random.Random instance\n",
      "    Return random integer in range [a, b], including both end points.\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(randint))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "\n",
    "9. <font color='green'> <b>Compléter</b> le programme suivant qui crée  une fonction `pile` qui prend comme argument un entier (le nombre de lancers) et retourne comme résultat le nombre de piles obtenus.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction qui simule le lancers d'une pièce de monnaie plusieurs fois\n",
    "___ pile(nb_lancers):\n",
    "    nb_pile = _\n",
    "    for cpt in ___(0,__________):\n",
    "        # on tire au sort 0 (Pile) ou 1 (Face) : utiliser randint\n",
    "        tirage = _______(_,_)\n",
    "        # si on obtient 0, on incrémente le nombre de piles\n",
    "        if tirage __ _:\n",
    "            nb_pile = ______ _ _\n",
    "    return nb_pile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Utiliser cette cellule pour tester votre fonction\n",
    "print(nb_pile(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. <font color='green'> **Ecrire** une fonction `somme_de()` qui simule le lancer de deux dés et calcule leur somme. Cette ne prend donc aucun argument et renvoie la somme de deux nombres tirés au hasard entre 1 un 6.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction somme de deux dés à 6 faces\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='orangered'> Les exercices suivants sont plus difficiles que ceux rencontrés auparavant, il est fortement conseillé de décomposer le problème et d'écrire des fonctions pour le résoudre</font>\n",
    "\n",
    "11. <font color='green'> <b>Ecrire</b> un programme Python qui lorsqu'on lui donne les trois longueurs $a$, $b$ et$c$ des côtés d'un triangle indique si oui ou non ce triangle est rectangle. On rappelle le théorème de Pythagore : \n",
    "    <blockquote> Un triangle est rectangle si et seulement si il vérifie l'<b>égalité de Pythagore</b></blockquote>\n",
    "L'égalité en question s'énonce ainsi : <i>\"le carré du plus grand côté est égal à la somme des carrés des deux autres côtés\"</i>. \n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme Pythagore\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12. <font color='green'> \n",
    "    On dispose de deux horaires sous forme heures et minutes. <b>Ecrire</b> un programme Python qui affiche la durée écoulée entre ces deux horaires.  Voici des exemples de fonctionnement : <ul>\n",
    "<li> <code>print(duree(13,20,14,40))</code> affichera <code>1h20mn</code> (durée entre 13h20 et 14h40)\n",
    "<li> <code>print(duree(16,30,17,10))</code> affichera <code>0h40mn</code> (durée entre 16h30 et 17h10)\n",
    "<li> <code>print(duree(22,50,1,15))</code> affichera <code>2h25mn</code>  (duréee entre 22h50 et 1h15 le lendemain) </ul>\n",
    "Comme vous pouvez le constater, sur le troisième exemple le deuxième horaire peut être dans la journée du lendemain. </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme calcul de durée\n"
   ]
  }
 ],
 "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
}