{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Travailler avec les fonctions : définir et appeler une fonction\n",
    "\n",
    "On a appris avec la carte Micro:Bit comment définir des fonctions en Python. \n",
    "Il s'agissait de fonctions simples, avec ou sans paramètre(s), qui avaient simplement comme utilité de remplacer quelques lignes de code. \n",
    "Dans d'autres langages elles auraient été appelées \"procédures\".\n",
    "\n",
    "## 1- Appeler une fonction qui renvoie un résultat :\n",
    "\n",
    "On peut donner un rôle beaucoup plus puissant à une fonction en lui demandant de \"renvoyer\" au programme qui l'a appelée le résultat de son travail.\n",
    "\n",
    "On connait déjà des fonctions qui ont un tel comportement et on les a utilisées sans souligner cette propriété.\n",
    "\n",
    "Prenons l'exemple de la fonction bin(nbre_entier) qui à l'issue de son exécution renvoie la conversion en binaire du paramètre nbre_entier. \n",
    "\n",
    "Essayer le code ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('La conversion en binaire du nombre décimal 5 donne :' , bin(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lors de l'évaluation de la fonction print(), l'interpréteur va évaluer la fonction bin(5).\n",
    "\n",
    "bin(5) va renvoyer la chaine de caractères '0b101' à la fonction print qui l'a appelée.\n",
    "\n",
    "La fonction print() peut alors concaténer la chaîne 'La conversion en binaire du nombre décimal 5 donne :' à la chaîne de caractère '0b101' renvoyée par la fonction bin()\n",
    "\n",
    "## 2- Créer une fonction qui renvoie un résultat :\n",
    "\n",
    "Une fonction qui **renvoie** un résultat possède dans sa **définition** le mot clé **return**. \n",
    "\n",
    "*Remarque :* on rencontre assez souvent le verbe **retourner** au lieu de **renvoyer**. Cette traduction trop rapide du verbe anglais **return** peut aboutir à des confusions. Par exemple, si on dit *que la fonction retourne une chaîne de caractères 'abc'* faut-il comprendre :\n",
    "  - qu'elle renvoie la chaîne 'abc' ?\n",
    "  - qu'elle transforme la chaîne 'abc' en 'cba' ?\n",
    "\n",
    "**Exemples de fonctions renvoyant un résultat :**\n",
    "\n",
    "On souhaite calculer le volume d'un cylindre. On pourrait donc créer une fonction qui applique directement la formule :\n",
    "\n",
    "![title](images/cylindre.png)\n",
    "\n",
    "Cette formule n'est rien d'autre que le produit de la surface de base du cylindre (un disque) par la hauteur h du cylindre. \n",
    "\n",
    "On peut donc, et c'est même souhaitable **décomposer** le calcul précédent en **utilisant deux fonctions** :\n",
    "\n",
    "  -l'une qui calculerait la surface d'un disque : **surface_disque(rayon)**\n",
    "\n",
    "  -l'autre qui calculerait le volume d'une forme simple droite (cylindre, mais aussi tous les polyèdres droits) : **volume(aire_base, h)**. \n",
    "\n",
    "*(Cette deuxième fonction pourra être utilisée pour d'autres formes droites : il suffira alors de l'associer à la bonne formule calculant la surface de base)*\n",
    "\n",
    "La fonction **surface_disque(rayon)**devra nous **renvoyer** la valeur de la surface du disque et cette valeur renvoyée pourra alors alimenter la deuxième fonction **volume(aire_base, h)** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math     # on importe le module de fonctions 'math' pour disposer de pi\n",
    "\n",
    "def surface_disque(rayon):\n",
    "    \"\"\"fonction qui calcule et renvoie la surface d'un disque\n",
    "    :param rayon: (int) ou (float) le rayon du disque\n",
    "    :return: (float) l'aire du disque (unité liée à celle du rayon)\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "def volume(aire_base,h):\n",
    "    \"\"\"fonction qui calcule et renvoie le volume d'une forme simple\n",
    "    :param aire_base: (int) ou (float) l'aire de la base du volume\n",
    "    :param h: (int) ou (float) la hauteur du volume \n",
    "    :CU: h et aire_base dans des unités compatibles\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "d = float(input('Entrer en cm le diamètre du cylindre : '))\n",
    "h = float(input('Entrer en cm la hauteur du cylindre : '))\n",
    "\n",
    "# Remarque : le volume calculé va être affiché avec une précision\n",
    "# excessive qui ferait bondir un professeur de physique...\n",
    "# on apprendra à régler ce genre de problème plus tard :\n",
    "\n",
    "print( 'Ce cylindre a un volume de ', ??? , 'cm3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Il est extrêmement important de bien comprendre tout le fonctionnement de ce script Python : c'est fondamental pour la suite du cours ! \n",
    "\n",
    "### ... il faut donc passer du temps à le lire, le décortiquer et l'analyser dans les moindres détails.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3- Applications :\n",
    "\n",
    "1- S'appuyer sur ce script pour écrire un programme qui calcule à l'aide de deux fonctions le volume d'un parallélépipède rectangle :\n",
    "\n",
    "![title](images/boite.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcul du volume d'un parallélépipède rectangle :\n",
    "def surface_rectangle(longueur, largeur):\n",
    "    \"\"\" fonction qui envoie la surface d'un rectangle\n",
    "    :param longueur: (int) ou (float) la longueur du rectangle\n",
    "    :param largeur: (int) ou (float) la largeur du rectangle\n",
    "    :return: (int) ou (float) la surface du rectangle\n",
    "    :CU: longueur et largeur dans la même unité\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# test de la fonction\n",
    "a = float(input('Entrer en cm la longueur du parallélépipède rectangle : '))\n",
    "b = float(input('Entrer en cm la largeur du parallélépipède rectangle : '))\n",
    "c = float(input('Entrer en cm la hauteur du parallélépipède rectangle : '))\n",
    "\n",
    "print( 'Ce cylindre a un volume de ', ??? , 'cm3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a vu avec ces deux exemples que l'on pouvait calculer le volume de toute forme droite à l'aide d'une seule fonction notée volume(aire_base,h) prenant en paramètre l'aire de la base, cette aire étant fournie par une autre fonction, qui elle, est spécifique de la forme étudiée.\n",
    "\n",
    "On peut donc envisager de se créer tout un catalogue de fonctions capables de calculer la surface de différentes formes planes simples. Ces fonctions pourront alors servir dans des calculs de volume ou pour tout autre chose\n",
    "\n",
    "## 4- Définitions de nouvelles fonctions :\n",
    "\n",
    "Ecrire la définition d'une fonction capable de renvoyer la surface d'un carré de côté 'a'. (Cette fonction pourra alimenter le calcul du volume d'un cube ou d'un parallélépipède rectangle à base carrée) :\n",
    "\n",
    "![title](images/carre.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction qui calcule la surface d'un carré :\n",
    "def surface_carre(arete):\n",
    "    \"\"\" fonction qui renvoie l'aire d'un carré\n",
    "    :param arete: (int) ou (float) l'arête du carré\n",
    "    :return: (int) ou (float) la surface du carré\n",
    "    Exemple :\n",
    "    >>> surface_carre(3)\n",
    "    9\n",
    "    \"\"\"\n",
    "    return ???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire la définition d'une fonction capable de renvoyer la surface d'un triangle dont on connait la longueur de la *base* ainsi que la *hauteur*. (Cette fonction pourra alimenter le calcul du volume d'un prisme à base triangulaire) :\n",
    "\n",
    "![title](images/prisme.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Fonction qui calcule la surface d'un triangle :\n",
    "def surface_triangle(base, hauteur):\n",
    "    \"\"\" fonction qui renvoie l'aire d'un triangle\n",
    "    :param base: (int) ou (float) la longueur de la base du triangle\n",
    "    :param base: (int) ou (float) la hauteur du triangle\n",
    "    :return: (int) ou (float) la surface du triangle\n",
    "    Exemple :\n",
    "    >>> surface_triangle(5, 3)\n",
    "    7.5\n",
    "    \"\"\"\n",
    "    return ???\n"
   ]
  },
  {
   "source": [
    "## 5- Application : calculer le volume d'une maison \n",
    "\n",
    "![maison.png](images/maison.png)\n",
    "\n",
    "*(src : http://www.sweethome3d.com)*\n",
    "\n",
    "Ecrire une fonction **volume_maison()** prenant en paramètres les quatre dimensions repérées sur le schéma ci-dessus (longueur, largeur, hauteur_mur, hauteur_faitage) et capable de renvoyer le volume de la maison.\n",
    "\n",
    "Le calcul du volume utilisera **plusieurs des fonctions** établies dans ce notebook\n",
    "\n",
    "Ecrire un programme demandant à l'utilisateur d'entrer en mètres chacune des dimensions nécessaires au calcul.\n",
    "Le programme lui renvoie alors :\n",
    "  - le rappel des données entrées\n",
    "  - le volume total de la maison et précise l'unité de mesure\n",
    "\n",
    "*Exemple de sortie affichée :*\n",
    "\n",
    "Avec une longueur de  10.0  mètres,\n",
    "\n",
    " une largeur de  8.0  mètres,\n",
    "\n",
    " une hauteur de façade de  6.0  mètres,\n",
    "\n",
    " et une hauteur de faîtage de  9.0  mètres,\n",
    " \n",
    "cette maison a un volume de  600.0  mètre-cubes\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ajouter uniquement les fonctions nécessaires :\n",
    "\n",
    "???\n",
    "...\n",
    "???\n",
    "\n",
    "# fonction pour calculer le volume de la maison :\n",
    "def volume_maison(longueur, largeur, hauteur_mur, hauteur_faitage):\n",
    "    \"\"\" fonction qui calcule le volume d'une maison\n",
    "    :param longueur: (int) ou (float) la longueur de la maison\n",
    "    :param largeur: (int) ou (float) la largeur de la maison\n",
    "    :param hauteur_mur: (int) ou (float) la hauteur de la façade de la maison\n",
    "    :param hauteur_faitage: (int) ou (float) la hauteur du faîtage de la maison\n",
    "    Exemple :\n",
    "    >>> volume_maison(10, 8, 6, 9)\n",
    "    600.0\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# mise en application:\n",
    "???\n",
    "...\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-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}