{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "46d9fbfe",
   "metadata": {},
   "source": [
    "<h2>  TP3 - Fonctions en Python </h2>  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db03e00b",
   "metadata": {},
   "source": [
    "<p> Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents, on peut l’isoler au sein d’une fonction.<br> Cette approche est également intéressante si la personne qui définit la fonction est différente de celle qui l’utilise. <br> Par exemple, nous avons déjà utilisé la fonction print() qui avait été définie par quelqu’un d’autre.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a11a2a23",
   "metadata": {},
   "source": [
    "<h3> Définition d’une fonction - def </h3>\n",
    "<ul>\n",
    "    <li> Syntaxe </li>\n",
    "\n",
    "La syntaxe Python pour la définition d’une fonction est la suivante :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b545e08",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nom_fonction(liste de paramètres):\n",
    "    bloc d'instructions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43114564",
   "metadata": {},
   "source": [
    "Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des mots-clés réservés du langage, et à la condition de n’utiliser aucun caractère spécial ou accentué (le caractère souligné « _ » est permis). Comme c’est le cas pour les noms de variables, on utilise par convention des minuscules, notamment au début du nom (les noms commençant par une majuscule seront réservés aux classes)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0af74d12",
   "metadata": {},
   "source": [
    "<li> Corps de la fonction</li>\n",
    "\n",
    "Comme les instructions if, for et while, l’instruction <b>def</b> est une instruction composée.<br> La ligne contenant cette instruction se termine obligatoirement par un deux-points : , qui introduisent un bloc d’instructions qui est précisé grâce à l’indentation.<br> Ce bloc d’instructions constitue le corps de la fonction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ac58123",
   "metadata": {},
   "source": [
    "<h3> Fonction sans paramètre </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "085c5302",
   "metadata": {},
   "source": [
    "exemple :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9834fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# executer le code suivant\n",
    "def compteur3():\n",
    "    i = 0\n",
    "    while i < 3:\n",
    "        print(i)\n",
    "        i = i + 1\n",
    "\n",
    "print(\"bonjour\")\n",
    "compteur3()\n",
    "compteur3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b75147c6",
   "metadata": {},
   "source": [
    "En entrant ces quelques lignes, nous avons défini une fonction très simple qui compte jusqu’à 2. <br>Notez bien les parenthèses, les deux-points, et l’indentation du bloc d’instructions qui suit la ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction proprement dite).\n",
    "\n",
    "Après la définition de la fonction, on trouve le programme principal qui débute par l’instruction print(\"bonjour\").<br> Il y a ensuite au sein du programme principal, 2 <strong>appels</strong> de la fonction grâce à compteur3(). <br>\n",
    "Après avoir exécuté ce script, pour utiliser à nouveau la fonction que nous venons de définir, il suffit de l’appeler par son nom au niveau du shell. Ainsi :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02c1df7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "compteur3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11687db3",
   "metadata": {},
   "source": [
    "Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de fois que nous le souhaitons.\n",
    "\n",
    "Nous pouvons également l’incorporer dans la définition d’une autre fonction.\n",
    "\n",
    "Exemple de fonction qui appelle une autre fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d1026d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compteur3():\n",
    "    i = 0\n",
    "    while i < 3:\n",
    "        print(i)\n",
    "        i = i + 1\n",
    "\n",
    "def double_compteur3():\n",
    "    compteur3()\n",
    "    compteur3()\n",
    "\n",
    "print(\"bonjour\")\n",
    "double_compteur3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae6ebdab",
   "metadata": {},
   "source": [
    "Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle une troisième, etc.\n",
    "\n",
    "Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un ensemble d’instructions. De cette manière, on peut simplifier le corps principal d’un programme, en dissimulant un algorithme secondaire complexe sous une commande unique, à laquelle on peut donner un nom explicite.\n",
    "\n",
    "Une fonction est donc en quelque sorte une nouvelle instruction personnalisée, qu’il est possible d’ajouter librement à notre langage de programmation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "375d1a47",
   "metadata": {},
   "source": [
    "<h3> Fonction avec paramètre </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b459674",
   "metadata": {},
   "source": [
    "exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c0c490a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compteur(stop):\n",
    "    i = 0\n",
    "    while i < stop:\n",
    "        print(i)\n",
    "        i = i + 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c1ec74c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# éxécuter \n",
    "compteur(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67236dcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "compteur(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39665ae0",
   "metadata": {},
   "source": [
    "Pour tester cette nouvelle fonction, il nous suffit de l’appeler avec un argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f878ebd",
   "metadata": {},
   "source": [
    "<h4> Utilisation d’une variable comme argument </h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cb62784",
   "metadata": {},
   "source": [
    "L’argument que nous utilisons dans l’appel d’une fonction peut être une variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cea233d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# executer ce code\n",
    "def compteur(stop):\n",
    "    i = 0\n",
    "    while i < stop:\n",
    "        print(i)\n",
    "        i = i + 1\n",
    "\n",
    "a = 5\n",
    "compteur(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7e518a8",
   "metadata": {},
   "source": [
    "<h3> Fonction avec plusieurs paramètres </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73f9629d",
   "metadata": {},
   "source": [
    "Exemple\n",
    "\n",
    "La fonction suivante utilise trois paramètres : \n",
    "<li> start qui contient la valeur de départ,</li>\n",
    "<li>stop la borne supérieure exclue comme dans l’exemple précédent </li>\n",
    "<li> et step le pas du compteur.</li>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a54f45db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compteur_complet(start, stop, step):\n",
    "    i = start\n",
    "    while i < stop:\n",
    "        print(i)\n",
    "        i = i + step\n",
    "\n",
    "compteur_complet(1, 7, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50096f1",
   "metadata": {},
   "source": [
    "Remarque :\n",
    "\n",
    "Pour définir une fonction avec plusieurs paramètres, il suffit d’inclure ceux-ci entre les parenthèses qui suivent le nom de la fonction, en les séparant à l’aide de virgules.\n",
    "\n",
    "Lors de l’appel de la fonction, les arguments utilisés doivent être fournis dans le même ordre que celui des paramètres correspondants (en les séparant eux aussi à l’aide de virgules). Le premier argument sera affecté au premier paramètre, le second argument sera affecté au second paramètre, et ainsi de suite."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "892d0b85",
   "metadata": {},
   "source": [
    "<h3> Variables locales, variables globales </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51924652",
   "metadata": {},
   "source": [
    "Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de l’ordinateur) un espace de noms.<br> Cet espace de noms local à la fonction est à distinguer de l’espace de noms global où se trouvait les variables du programme principal.<br> Dans l’espace de noms local, nous aurons des variables qui ne sont accessibles qu’au sein de la fonction. C’est par exemple le cas des variables start, stop, step et i dans l’exemple précédent.\n",
    "\n",
    "A chaque fois que nous définissons des variables à l’intérieur du corps d’une fonction, ces variables ne sont accessibles qu’à la fonction elle-même. <br>On dit que ces variables sont des variables locales à la fonction. Une variable locale peut avoir le même nom qu’une variable de l’espace de noms global mais elle reste néanmoins indépendante.\n",
    "\n",
    "Les contenus des variables locales sont stockés dans l’espace de noms local qui est inaccessible depuis l’extérieur de la fonction.\n",
    "\n",
    "Les variables définies à l’extérieur d’une fonction sont des variables globales. Leur contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le modifier."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78257065",
   "metadata": {},
   "source": [
    "exemple "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5b7ff59",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test():\n",
    "    b = 5\n",
    "    print(a, b)\n",
    "    \n",
    "a = 2\n",
    "b = 7\n",
    "test()\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "618ebec2",
   "metadata": {},
   "source": [
    "Explications en vidéo : https://youtu.be/HTaOCnBaQfo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "346c0e89",
   "metadata": {},
   "source": [
    "<h4> Utilisation d’une variable globale - global </h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f33d86c6",
   "metadata": {},
   "source": [
    "Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de modifier une variable globale. Pour atteindre ce résultat, il vous suffira d’utiliser l’instruction global. Cette instruction permet d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont les variables à traiter globalement.\n",
    "\n",
    "On va ici créer une fonction qui a accès à la variable globale b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8759b967",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test():\n",
    "    global b\n",
    "    b = 5\n",
    "    print(a, b)\n",
    "    \n",
    "a = 2\n",
    "b = 7\n",
    "test()\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d42910e",
   "metadata": {},
   "source": [
    "<h3> « Vraies » fonctions et procédures </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd4617c",
   "metadata": {},
   "source": [
    "Pour les puristes, les fonctions que nous avons décrites jusqu’à présent ne sont pas tout à fait des fonctions au sens strict, mais plus exactement des procédures. <br> Une « vraie » fonction (au sens strict) doit en effet renvoyer une valeur lorsqu’elle se termine avec utilisation du <strong> return </strong>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ae4ad37",
   "metadata": {},
   "source": [
    "un exemple simple "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8bd875a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube(w):\n",
    "    return w**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f7651407",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "a = cube(4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd25c446",
   "metadata": {},
   "source": [
    "<h4> le return est nécéssaire losqu'on veut sauvegarder le résultat de l'appel de la fonction </h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8afa328",
   "metadata": {},
   "source": [
    "<h3>Valeurs par défaut pour les paramètres </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e064951f",
   "metadata": {},
   "source": [
    "Dans la définition d’une fonction, il est possible de définir un argument par défaut pour chacun des paramètres. <br>On obtient ainsi une fonction qui peut être appelée avec une partie seulement des arguments attendus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aa870e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def politesse(nom, titre =\"Monsieur\"):\n",
    "    print(\"Veuillez agréer,\", titre, nom, \", mes salutations distinguées.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec44a836",
   "metadata": {},
   "outputs": [],
   "source": [
    "politesse(\"Dupont\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eacf061",
   "metadata": {},
   "outputs": [],
   "source": [
    "politesse('Durand', 'Mademoiselle')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e486e74",
   "metadata": {},
   "source": [
    "Lorsque l’on appelle cette fonction en ne lui fournissant que le premier argument, le second reçoit tout de même une valeur par défaut.<br> Si l’on fournit les deux arguments, la valeur par défaut pour le deuxième est tout simplement ignorée."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}