06-Fonctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "123567b9-cc30-4755-9e5f-176d3bbe32e1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# **Les fonctions**\n",
    "## Objectifs \n",
    "- Définir une fonction.\n",
    "- Une fonction qui retourne une donnée.\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c89b72e-9d87-4e17-8928-afddbfa7178e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Comment créer une fonction?\n",
    "- Les fonctions que l'on crée sont traitées par le système comme les fonctions internes.\n",
    "- En principe, elles doivent effectuer une tâche simple et unique.\n",
    "- On définit une nouvelle fonction avec la syntaxe suivante :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db7803f5-4a2c-4d28-905b-c73bf608c4d0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "```R\n",
    "fun = function(arguments) { expression }\n",
    "```\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00585e3c-f32c-416f-8f88-33e4932c0317",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## En détail:\n",
    "\n",
    "- `fun` : Nom de la fonction (mêmes règles que le nom d'une variable).\n",
    "- `function` : Mot clé pour une fonction.\n",
    "- `arguments` : Liste des arguments séparés par des virgules.\n",
    "- `expression` : Corps de la fonction. Entre accolades. On utilise 4 espaces ou 1 tab pour l'indentation.\n",
    "  \n",
    "Ici, la fonction **`fahrenheit_a_celsius()`** prend en argument une température en Fahrenheit et retourne la conversion en Celsius."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43b4eb8c-e451-4249-8679-f61e4db3d4de",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fahrenheit_a_celsius = function(temp_F) {\n",
    "  # Cette fonction prend en valeur une température en Fahrenheit et retourne l'équivalent en Celsius.\n",
    "  temp_C = (temp_F - 32) * 5 / 9\n",
    "  return(temp_C)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3cc13cf-1d6b-476f-bb9d-02a436cc373b",
   "metadata": {},
   "source": [
    "On appelle la fonction comme on le ferait avec n'importe quelle fonction:\n",
    "\n",
    "Il est important de documenter ses fonctions. En R, on utilise le `#`. \n",
    "1. On le fait pour nous afin d'avoir une référence dans le futur.\n",
    "2. Pour un collègue qui voudrait l'utiliser."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fb6ddf8-b191-4057-9947-178e20ab8c86",
   "metadata": {},
   "source": [
    "En R, on n’est pas obligé de placer la valeur de retour avec un *`return`*. Par contre, il est très fortement suggéré de mettre le *`return`* pour une bonne lisibilité du code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ad091c6-f4a0-4e07-83bf-de016986c355",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fahrenheit_a_celsius(32) # Point de congélation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e61b104-8c5e-4a9a-9f87-6f0f8300c5a1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "921d3b52-87f9-4821-bc78-2c16e64a0769",
   "metadata": {},
   "source": [
    "Maintenant on peut passer de Celsius à Kelvin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03165f24-bdc6-4eb0-a27d-b2ef5b7cdbfd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "celsius_a_kelvin = function(temp_C) {\n",
    "  # Cette fonction prend en valeur une température en Celsius et retourne l'équivalent en Kelvin.\n",
    "  temp_K = temp_C + 273.15\n",
    "  return(temp_K)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ac46a09-4594-4a6d-9b77-0ca63d4a3ddd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Appeler la fonction `celsius_a_kelvin()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81443afd-a017-4c01-adb4-fba234a24dc7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9bac3e29-1f9e-40d2-8786-e5cb4b8ed72e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "On a une fonction `fahrenheit_a_celsius()` et `celsius_a_kelvin()`.\n",
    "\n",
    "Pour passer de **Fahrenheit** à **Kelvin**, on réutilise le code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7e34d9a-6c29-482b-8cb4-fa8aeee0f31f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fahrenheit_a_kelvin = function(temp_F) {\n",
    "  # Cette fonction prend en valeur une température en Fahrenheit et retourne l'équivalent en Kelvin.\n",
    "  temp_C = fahrenheit_a_celsius(temp_F)\n",
    "  temp_K = celsius_a_kelvin(temp_C)\n",
    "  return(temp_K)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3008fb0f-b7ca-4150-ab1e-970af898a10d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Appeler la fonction `fahrenheit_a_kelvin()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a20e5890-fcb2-4809-8720-eb84144345b1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f9a7911b-4d78-407a-8018-78bfb42ff863",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Allons un peu plus loin : Imbrication de fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8483f718-680e-4e5b-9729-422d9e37a0ec",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bf289bf2-4a04-4fa0-8c3d-b8426aa28643",
   "metadata": {},
   "source": [
    "## Autre exemple:\n",
    "On veut créer une fonction qui nous retourne un vecteur qui contient le premier et le dernier élément du vecteur principal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14f6ff22-61bd-451e-91f6-a85727caef93",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "limites = function(v) {\n",
    "  # Fonction qui retourne un vecteur qui contient le premier et dernier élément du vecteur.   \n",
    "  premier = v[1]\n",
    "  dernier = v[length(v)]\n",
    "  reponse = c(premier, dernier)\n",
    "  return(reponse)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5084bfd0-c087-4c38-bf2e-fcb78a127e9f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "vecteur = 1:10\n",
    "limites(vecteur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7dad8ec-09cf-44c8-9382-6b840207c07e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "limites(c(5, 9, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68029208-6309-4683-8e17-314327e8b829",
   "metadata": {},
   "source": [
    "Un argument avec une valeur par défaut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1efca932-a39d-4262-9610-dd7b32715e67",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "puissance = function(x, y = 2) {\n",
    "  # Cette fonction retourne la puissance de x à la y.\n",
    "  return(x^y)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f763981-f1ec-44f3-8576-f3ee2cbf1eb2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "## **Exercice-1:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25553dcb-3c1a-4aca-a9a1-5620fdcdb926",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Appelle la fonction `puissance()` en donnant ou pas une valeur pour `y`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "681cd891-b6cd-410a-ab9d-1967a600e8c6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3794c306-19fa-48de-b966-0f9b486ce6c5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "C'est possible d'intégrer nos conditions dans une fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bf9664a-4e0a-451b-8541-cde0b9d4bc52",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "signe = function(numero) {\n",
    "  # Fonction qui retourne si le nombre est positif, négatif ou égal à zéro.\n",
    "  if (numero > 0) {\n",
    "    return(\"positif\")\n",
    "  } else if (numero == 0) {\n",
    "    return(\"zero\")\n",
    "  } else {\n",
    "    return(\"negatif\")\n",
    "  }\n",
    "}\n",
    "\n",
    "signe(-3)\n",
    "signe(35214)\n",
    "signe(0)\n",
    "signe(2/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "409eb662-4994-4de3-9e80-e79a96f46802",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "## **Exercice-2:**\n",
    "Écrire une fonction qui retourne une liste avec l'aire et le périmètre d'un rectangle. \n",
    "\n",
    "La fonction prend en paramètre la longueur et la largeur. \n",
    "\n",
    "Ajouter l'aire et le périmètre comme attribut de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d6e85ba-bc4e-4165-b43d-3cab65f0157d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b57aba44-eeab-4cbd-8fb7-d7fc01d63cde",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Appeler la fonction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "333e9d91-d134-4ae6-b5d1-cb112a570510",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1e720454-d102-4c2e-9f76-c0708c82cbc7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "## Tester nos fonctions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0415af6e-3eb5-4613-a1c9-c83c48be30ca",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Il est important de vérifier la validité de nos fonctions.\n",
    "\n",
    "- Pour ce faire, on peut appeler la fonction et afficher le résultat d'un test d'égalité.\n",
    "\n",
    "- On peut utiliser une assertion. Si elle est valide, le résultat du test sera `TRUE`, sinon, on va lever une exception et le code ou la fonction ne sera pas effectuée. Cette pratique est très utile pour prévenir les erreurs et s'assurer de la validité du code.\n",
    "\n",
    "On a plusieurs options avec le R.\n",
    "1. `stopifnot()` : Fonction R de base.\n",
    "2. `assert()` : On a besoin d'installer le package `testit` : `install.packages(\"testit\")`\n",
    "3. `assert()` : Est disponible aussi via le package `assertr`: `install.packages(\"assertr\")`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d5fb524-3941-4cad-8c36-963ceafb4109",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(fahrenheit_a_celsius(32) == 0)  # Devrait retourner TRUE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38647e7a-7ae9-4632-9e46-d0cb1974f48e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "stopifnot(fahrenheit_a_celsius(32) == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85d16a2b-f58e-4eaf-b3d8-54421f243da8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "empty"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5096a37d-387c-45af-bae5-9fd6b11ef1ac",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "---\n",
    "## En résumé:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d765197-287e-4c7a-a650-83b003521cdf",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "- Important de garder notre fonction le plus simple possible.\n",
    "- Ajouter une courte description au début de la fonction.\n",
    "- On défini une fonction de cette façon : nom_de_la_fonction = function(...argument...) {...corps...}.\n",
    "- On appelle une fonction de cette façon : nom_de_la_fonction(...valeurs...).\n",
    "- On peut spécifier une valeur par défaut.\n",
    "- Intégrer des assertions pour valider nos fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88b42d09-1c15-40b0-b2f2-4c7bbe904df8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.2.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}