5_fonctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "# Programmation Python 3 - Les fonctions"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Définition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manière dont un développeur va écrire son code est un paradigme de programmation. Ainsi, un paradigme de programmation est une approche logique qu'un développeur va adopter pour résoudre son problème.  \n",
    "\n",
    "Depuis que vous travaillez en langage Python, vous utilisez un paradigme impératif, en effet les étapes d'instruction se suivent jusqu'à aboutir au résultat attendu. Cette méthode de résolution consiste à réaliser des instructions les unes à la suite des autres. C'est une approche efficace pour les programmes/scripts courts avec peu d'instructions. Le code impératif (aussi appelé code procédural) n'est pas réutilisable.  \n",
    "\n",
    "Ainsi, il existe d'autres paradigmes permettant de réaliser les instructions de la manière dont nous les souhaitons, comme par exemple, le paradigme objet ou le paradigme fonctionnel.  \n",
    "\n",
    "- La programmation orientée objet consiste à designer son code sous forme d'objets ayant des propriétés (appelées attributs) et des capacités d'action (appelées méthodes) qui interagissent entre eux plutôt qu'une séquence d'instructions.  \n",
    "  \n",
    "- La programmation fonctionnelle permet de décomposer un problème en un ensemble de fonctions. Dans l'idéal, les fonctions produisent des sorties à partir des entrées et ne possèdent pas d'état interne qui soit susceptible de modifier la sortie pour une entrée donnée. Le paradigme fonctionnel cherche à éviter au maximum les effets de bord, en programmation fonctionnelle, on va éviter de modifier les valeurs associées à des variables globales. \n",
    "\n",
    "Dans les deux cas, les objets ou les fonctions sont des briques réutilisables qui rendent le pool code modulaire et découplé."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En programmation, une approche efficace d'un problème complexe revient à le décomposer en plusieurs sous-problèmes plus simples qui peuvent eux-mêmes être décomposés à leur tout jusqu'à aboutir à un des sous-sous-sous...problèmes simples.  \n",
    "Il est également fréquent de vouloir répéter une même séquence d'instructions, à plusieurs reprises sans pour autant avoir à réécrire les instructions concernées, c'est le rôle des **fonctions**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Généralités"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En plus de permettre une répétition d'instructions autant de fois que désiré, les fonctions rendent le code plus lisible et plus clair.  \n",
    "Vous avez déjà utilisé des fonctions built-in, c.-à-d. préprogrammées telles que `len`, `range` ou même la méthode `randint` du module `random`.  \n",
    "Lors de l'utilisation de ces fonctions vous avez passé aucune, une ou plusieurs variables ou valeurs entre les parenthèses, comme par exemple `len(liste)`, `range(2, 9, 2)` ou `randint(1, 100)`. Ces variables ou valeurs sont appelées des **arguments** et sont nécessaires à la fonction afin que celle-ci s'exécute correctement. Les arguments peuvent être de n'importe quel type et sont propres à la fonction utilisée. Il est possible qu'une fonction n'ait pas besoin d'arguments.   \n",
    "\n",
    "Après l'exécution de la fonction, celle-ci peut renvoyer aucune, une ou plusieurs variables ou valeurs en sortie comme par exemple `len(liste)` qui renvoie une donnée numérique de type entier égale à la longueur de l'argument, ici `liste`, ou `liste.append(4)` qui ajoute l'argument à la fin de `liste` mais ne renvoie rien.  \n",
    "\n",
    "En général, une fonction effectue une tâche **unique** et **précise**. Il vaut mieux décomposer le programme en de nombreuses petites sous-tâches appelées fonctions plutôt que de créer moitié moins de fonctions qui à elles-seules réaliser plusieurs tâches.\n",
    "Le code en sera d'autant plus lisible et clair.\n",
    "C'est le concept de responsabilité unique en architecture logicielle. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Déclaration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour pouvoir utiliser une fonction, il faut réaliser deux actions essentielles :\n",
    "1. Déclaration de la fonction\n",
    "2. Appel de la fonction  \n",
    "\n",
    "L'appel de la fonction peut être réalisé dans la fonction elle-même, dans une autre fonction, ou dans le programme principal. Il s'agit de la partie du code qui est exécuté quand le programme est lancé. Le programme principal se situe après les définitions de fonctions. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour déclarer ou définir une fonction, il faut utiliser le mot-clé `def` suivi du nom que l'on souhaite donner à la fonction. **Attention, comme pour les noms de variables, il est recommandé de donner des noms significatifs**.  \n",
    "\n",
    "La syntaxe d'écriture pour déclarer une fonction est la suivante : "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.516009Z",
     "start_time": "2024-10-25T15:36:52.506378Z"
    }
   },
   "source": [
    "def nom_significatif_de_la_fonction_avec_verbe(argument1, argument2, ...):\n",
    "    instruction1\n",
    "    instruction2\n",
    "    instruction3\n",
    "    ..."
   ],
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1806011812.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001B[0;36m  Cell \u001B[0;32mIn[1], line 1\u001B[0;36m\u001B[0m\n\u001B[0;31m    def nom_significatif_de_la_fonction_avec_verbe(argument1, argument2, ...):\u001B[0m\n\u001B[0m                                                                         ^\u001B[0m\n\u001B[0;31mSyntaxError\u001B[0m\u001B[0;31m:\u001B[0m invalid syntax\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est important de penser aux éléments suivants lors de la définition d'une fonction: \n",
    "* Ne pas oublier le mot-clé **def** en début de la définition\n",
    "* Donner un nom significatif à la fonction\n",
    "* Ne pas oublier les parenthèses même s'il n'y pas d'arguments !\n",
    "* Ne pas oublier les **:** à la fin de l'instruction de définition\n",
    "* Ne pas oublier l'**indentation** pour les instructions qui composent la fonction. "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "#Exemple de déclaration d'une fonction sans argument\n",
    "#----- Début Declaration de fonctions -----\n",
    "def message_de_bienvenue():\n",
    "    print(\"Bienvenue dans le chapitre sur les fonctions\")\n",
    "\n",
    "#----- Fin Declaration de fonctions -----"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En exécutant la cellule ci-dessus on constate que rien ne se passe, en effet seule la définition de la fonction a été réalisée. L'appel de la fonction est absent. "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.529363Z",
     "start_time": "2024-10-25T15:36:52.521126Z"
    }
   },
   "source": [
    "#Exemple de déclaration d'une fonction sans argument\n",
    "#----- Début Declaration de fonctions -----\n",
    "def message_de_bienvenue():\n",
    "    print(\"Bienvenue dans le chapitre sur les fonctions\")\n",
    "\n",
    "\n",
    "#----- Fin Declaration de fonctions -----\n",
    "\n",
    "#----- Début Programme Principal -----\n",
    "message_de_bienvenue()\n",
    "#----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bienvenue dans le chapitre sur les fonctions\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Après appel de la fonction, on constate bien son exécution. \n",
    "Lors de l'appel de la fonction, il faut veiller à :\n",
    "* Appeler la fonction avec son nom correctement saisi\n",
    "* Ne pas oublier les parenthèses même s'il n'y a pas d'argument\n",
    "* S'il y en a, ne pas oublier les arguments dans les parenthèses"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.543230Z",
     "start_time": "2024-10-25T15:36:52.533215Z"
    }
   },
   "source": [
    "#Exemple de déclaration d'une fonction avec arguments\n",
    "#----- Début Declaration de fonctions -----\n",
    "def message_de_bienvenue(message, repetitions):\n",
    "    for i in range(repetitions):\n",
    "        print(message)\n",
    "\n",
    "\n",
    "#----- Fin Declaration de fonctions -----\n",
    "\n",
    "#----- Début Programme Principal -----\n",
    "mon_message = \"Bonjour\"\n",
    "nb_repetitions = 3\n",
    "message_de_bienvenue(mon_message, nb_repetitions)\n",
    "#----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour\n",
      "Bonjour\n",
      "Bonjour\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les exemples que nous venons de traiter seront plus considérés comme des ***procédures*** et non de \"vraies\" fonctions. En effet, une fonction doit renvoyer une valeur lorsque celle-ci termine de s'exécuter, ce qui engendre que dans le programme principal, la valeur retournée doit être assignée à une variable.  \n",
    "\n",
    "C'est l'instruction `return` qui permet de renvoyer une ou plusieurs valeurs. "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.599046Z",
     "start_time": "2024-10-25T15:36:52.591300Z"
    }
   },
   "source": [
    "# Exemple de déclaration d'une fonction retournant une valeur\n",
    "# ----- Début Declaration de fonctions -----\n",
    "def additionner(nb1, nb2=30.0):\n",
    "    res = nb1 + nb2\n",
    "    return res\n",
    "\n",
    "\n",
    "# ----- Fin Declaration de fonctions -----\n",
    "\n",
    "# ----- Début Programme Principal -----\n",
    "val1 = 37.19\n",
    "val2 = 87.34\n",
    "ex1_somme = additionner(val1, val2)\n",
    "print(ex1_somme)\n",
    "ex2_somme = additionner(val1)\n",
    "print(ex2_somme)\n",
    "# ----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124.53\n",
      "67.19\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exemple présenté ci-dessus, on constate donc que la variable `ex1_somme` prend la valeur retournée par le premier appel de fonction de `additionner` avec les valeurs `37.19` et `87.34`.  \n",
    "Pour la variable `ex2_somme` celle-ci prend la valeur retournée par le second appel de fonction mais où un seul paramètre n'est spécifié alors que deux sont nécessaires comme mentionnée dans la définition de la fonction.  \n",
    "**Dans la definition d'une fonction, il est possible de définir une valeur par défaut des arguments**. Cette valeur définit par défaut n'est pas prioritaire et est ainsi ignorée lorsque la valeur est spécifiée lors de l'appel de fonction.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "Afin de rendre le code plus lisible et clair, il est possible d'annoter les fonctions. Pour cela, chaque paramètre va être suivi de son type, ainsi que le type retourné par la fonction à la fin de son exécution. "
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.626492Z",
     "start_time": "2024-10-25T15:36:52.619617Z"
    }
   },
   "source": [
    "# Exemple de déclaration d'une fonction avec annotations\n",
    "# ----- Début Declaration de fonctions -----\n",
    "def additionner(nb1: float, nb2: float = 30.0) -> float:\n",
    "    res = nb1 + nb2\n",
    "    return res\n",
    "\n",
    "\n",
    "# ----- Fin Declaration de fonctions -----\n",
    "\n",
    "# ----- Début Programme Principal -----\n",
    "val1 = 37.19\n",
    "val2 = 87.34\n",
    "ex1_somme = additionner(val1, val2)\n",
    "print(ex1_somme)\n",
    "ex2_somme = additionner(val1)\n",
    "print(ex2_somme)\n",
    "# ----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124.53\n",
      "67.19\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exemple ci-dessus, on constate donc que les deux arguments doivent être tous les deux type `float` (il faut séparer le nom de la variable du type avec `:`). Le type retourné par la fonction doit être spécifié entre les arguments et le caractère `:` en utilisant les caractères `->` suivi du type. Ce n'est qu'un _type hinting_ une indication, elle peut être fausse.\n",
    "***Attention, l'annotation de fonctions est optionnelle, ainsi lors de l'appel de la fonction le paramètre n'est pas du même type que celui mentionné dans la définition de la fonction, aucune erreur ne sera généré. C'est à la charge du développeur de vérifier que les types des paramètres sont bien conformes***.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables globales et locales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La portée des variables est un point important dans le paradigme fonctionnel. En effet, en fonction de l'endroit dans le script où les variables sont définies va être déterminant sur leur utilisation. En Python, une variable peut avoir une portée (espaces dans lesquels la variable est accessible) **locale** ou une portée **globale**.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Une variable **globale** peut être accessible n'importe où dans le script. \n",
    "- Une variable **locale** est accessible uniquement à l'intérieur d'un bloc de code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**En Python, si une variable n'est pas modifiée dans une fonction mais seulement lue, elle est implicitement considérée comme globale. Si une valeur lui est affectée, elle est considérée comme locale (sauf si elle est explicitement déclarée globale)**.  \n",
    "\n",
    "L'exemple ci-dessous illustre la règle présentée ci-dessus : "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.821268Z",
     "start_time": "2024-10-25T15:36:52.813006Z"
    }
   },
   "source": [
    "# Exemple de déclaration d'une variable globale\n",
    "# ----- Début déclaration variable globale -----\n",
    "res = 0\n",
    "\n",
    "\n",
    "# ----- Fin déclaration variable globale -----\n",
    "\n",
    "# ----- Début Declaration de fonctions -----\n",
    "def additionner(nb1: float, nb2: float = 30.0) -> float:\n",
    "    res = nb1 + nb2\n",
    "    return res\n",
    "\n",
    "\n",
    "# ----- Fin Declaration de fonctions -----\n",
    "\n",
    "# ----- Début Programme Principal -----\n",
    "val1 = 37.19\n",
    "val2 = 87.34\n",
    "ex1_somme = additionner(val1, val2)\n",
    "print(ex1_somme)\n",
    "ex2_somme = additionner(val1)\n",
    "print(ex2_somme)\n",
    "print(\"Affichage valeur de la variable globale res: \", res)\n",
    "# ----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124.53\n",
      "67.19\n",
      "Affichage valeur de la variable globale res:  0\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'exemple on constate que la variable `res` est déclarée en variable globale. Dans la fonction `additionner`, la variable `res` se voit affecter une valeur. Cette variable porte le même nom que la variable globale. La variable `res` définit dans la fonction est donc une variable locale et n'est accessible qu'au sein de cette fonction. Pour preuve, à la fin du programme un affichage de la variable `res` est demandé et c'est la valeur 0 qui est affichée, cette valeur étant celle assignée par défaut au moment de la déclaration de la variable globale, la valeur n'a donc pas été modifiée au sein de la fonction.  \n",
    "\n",
    "Si le but est de modifier la valeur de la variable globale, il faut alors le déclarer explicitement comme présenté ci-dessous : "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.844616Z",
     "start_time": "2024-10-25T15:36:52.834592Z"
    }
   },
   "source": [
    "# Exemple de déclaration d'une variable globale\n",
    "# ----- Début déclaration variable globale -----\n",
    "res = 0\n",
    "\n",
    "\n",
    "# ----- Fin déclaration variable globale -----\n",
    "\n",
    "# ----- Début Declaration de fonctions -----\n",
    "def additionner(nb1: float, nb2: float = 30.0) -> float:\n",
    "    global res\n",
    "    res = nb1 + nb2\n",
    "    return res\n",
    "\n",
    "\n",
    "# ----- Fin Declaration de fonctions -----\n",
    "\n",
    "# ----- Début Programme Principal -----\n",
    "val1 = 37.19\n",
    "val2 = 87.34\n",
    "ex1_somme = additionner(val1, val2)\n",
    "print(ex1_somme)\n",
    "ex2_somme = additionner(val1)\n",
    "print(ex2_somme)\n",
    "print(\"Affichage valeur de la variable globale res: \", res)\n",
    "# ----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124.53\n",
      "67.19\n",
      "Affichage valeur de la variable globale res:  67.19\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "L'instruction `global` permet de spécifier que la variable qui suit est une variable globale, pour preuve à la fin de l'exécution du script on constate que la valeur finale de la variable globale `res` n'est plus égale à 0 mais au résultat de l'addition opérée au sein de la fonction. "
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "Toutefois, l'utilisation de l'instruction `global` est déconseillée car ce n'est pas une bonne pratique et doit dans la limite du possible être évitée. Si le but est de modifier le contenu d'une variable globale, il est préférable d'utiliser la valeur retournée par la fonction.\n"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un script Python sera plus souvent lu qu'écrit, en ce sens il est primordial de rendre son contenu clair, lisible afin de faciliter sa lecture et sa compréhension. En plus des noms de variables, les noms des fonctions qui doivent être significatifs, il est opportun de mettre des commentaires à tout script Python ainsi qu'une documentation à chaque fonction déclarée. Cette documentation se présente sous la forme de *docstring*. Cette documentation se présente sous la forme d'un paragraphe entouré des caractères `\"\"\"` et se situe au tout début de la définition de la fonction.  \n",
    "Il s'agit d'une explication textuelle et doit a minima contenir les éléments suivants : \n",
    "- Une phrase présentant l'objectif de la fonction. Cette phrase doit permettre de répondre à la question \"A quoi sert cette fonction ?\". \n",
    "- Préciser les types de données (arguments) ainsi que leur utilité. \n",
    "- Préciser les types de sorties (données retournées) ainsi que leur utilité.  \n",
    "\n",
    "Un exemple ci-dessous vous présentant un format RST (le plus classique) de docstring : "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.943393Z",
     "start_time": "2024-10-25T15:36:52.933491Z"
    }
   },
   "source": [
    "# Exemple de déclaration d'une variable globale\n",
    "# ----- Début déclaration variable globale -----\n",
    "res = 0\n",
    "\n",
    "\n",
    "# ----- Fin déclaration variable globale -----\n",
    "\n",
    "# ----- Début Declaration de fonctions -----\n",
    "def additionner(nb1: float, nb2: float = 30.0) -> float:\n",
    "    \"\"\"Calcul d'une somme entre deux nombres\n",
    "    \n",
    "       :param nb1: Premier nombre à additionner, type float\n",
    "       :param nb2: Second nombre à additionner, type float (defaut: 30.0)\n",
    "    \n",
    "       return res: Résultat de l'addition, type float\n",
    "    \"\"\"\n",
    "    res = nb1 + nb2\n",
    "    return res\n",
    "\n",
    "\n",
    "# ----- Fin Declaration de fonctions -----\n",
    "\n",
    "# ----- Début Programme Principal -----\n",
    "val1 = 37.19\n",
    "val2 = 87.34\n",
    "ex1_somme = additionner(val1, val2)\n",
    "print(ex1_somme)\n",
    "ex2_somme = additionner(val1)\n",
    "print(res)\n",
    "print(\"Affichage valeur de la variable globale res: \", res)\n",
    "# ----- Fin Programme Principal -----"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124.53\n",
      "0\n",
      "Affichage valeur de la variable globale res:  0\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "#### ***Exercice 1***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Des lettres et des lettres !***  \n",
    "\n",
    "Écrire un script Python en adoptant le paradigme fonctionnel et permettant au joueur de jouer à une version simplifiée du Scrabble. \n",
    "Le joueur se voit attribuer 7 lettres au hasard. Ce dernier doit ensuite former un mot avec les lettres à sa disposition. Si le mot proposé par le joueur est possible, c'est-à-dire qu'il peut être écrit à partir des lettres à sa disposition, le joueur gagne un nombre de points égal au nombre de lettres du mot. Dans le cas contraire si pas de proposition ou si le mot ne peut pas être écrit dans sa totalité avec les lettres à la disposition du joueur, ce dernier se voit attribué le score de 0. \n",
    "\n",
    "*Exemple:*  \n",
    "- Lettres à la disposition du joueur : NBJORUO\n",
    "- Proposition du joueur : JOUR -> Score = 4\n",
    "- Autre proposition du joueur : SALUT -> Score = 0                 \n",
    "  \n",
    "1. Attention aux commentaires\n",
    "2. Attention aux docstring\n",
    "3. Attention aux noms de variables.  \n",
    "\n",
    "*Faites valider votre script ainsi que son exécution.* \n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ***Exercice 2***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En vous appuyant sur le script de l'exercice 1, écrire un script Python en adoptant le paradigme fonctionnel et permettant de jouer au scrabble. \n",
    "Les valeurs des lettres sont les suivantes : \n",
    "- 0 point: Joker (permet de remplacer n'importe quelle lettre)\n",
    "- 1 point: E, A, I, N, O, R, S, T, U, L\n",
    "- 2 points: D, G, M\n",
    "- 3 points: B, C, P\n",
    "- 4 points: F, H, V\n",
    "- 8 points: J, Q\n",
    "- 10 points: K, W, X, Y, Z  \n",
    "\n",
    "1. Attention aux commentaires\n",
    "1. Attention aux docstring\n",
    "1. Attention aux noms de variables.  \n",
    "\n",
    "*Faites valider votre script ainsi que son exécution.*"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***\n",
    "## Les fonctions lambda\n",
    "\n",
    "Inspirée de la programmation fonctionnelle, cette syntaxe permet de déclarer une fonction simple."
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:52.975402Z",
     "start_time": "2024-10-25T15:36:52.968145Z"
    }
   },
   "cell_type": "code",
   "source": [
    "is_even = lambda n: n % 2 == 0\n",
    "print(\"Is 5 even: \", is_even(5))\n",
    "is_odd = lambda n: not is_even(n)\n",
    "print(\"Is 5 odd: \", is_odd(5))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is 5 even:  False\n",
      "Is 5 odd:  True\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Toujours inspirée de la programmation fonctionnelle, cette syntaxe est souvent utilisée avec `map`, `functools.reduce`, `functools.filter`."
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:53.063846Z",
     "start_time": "2024-10-25T15:36:53.055237Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Liste les booléens jusqu'à 10\n",
    "print(list(map(is_odd, range(10))))\n",
    "# Filtre les nombres pairs\n",
    "# map est built-in alors que filter et reduce font partie d'une libraire dédiée,\n",
    "# functools (https://docs.python.org/fr/3/library/functools.html) à programmation fonctionnelle.\n",
    "print(list(filter(is_odd, range(10))))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, True, False, True, False, True, False, True, False, True]\n",
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Exercice 3\n",
    "\n",
    "Écrire une fonction lambda qui donne la racine d'une liste de nombres."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### `functools.partial`\n",
    "\n",
    "Toujours dans la mouvance de la programmation fonctionnelle permet de créer une nouvelle fonction en modifiant une existante en fixant un argument.\n",
    "\n",
    "Par exemple `int` prend une chaîne de caractère et une base pour retourner un entier.\n",
    "On peut en créer une dédiée au binaire :"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:53.081768Z",
     "start_time": "2024-10-25T15:36:53.074485Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from functools import partial\n",
    "\n",
    "int_bin = partial(int, base=2)\n",
    "print(\"En base 10, 0101110 vaut: \", int_bin(\"0101110\"))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "En base 10, 0101110 vaut:  46\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Exercice 4\n",
    "\n",
    "Modifier avec partial la fonction built-in `pow` *to the POWer of* pour qu'elle retourne toujours le résultat modulo 7."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Exercice 5, la conjecture de Goldbach\n",
    "\n",
    "En utilisant des fonctions, classiques voir `lambda`, voir des functions issues du module `functools`.\n",
    "Vérifier la conjecture de Goldbach qui dit que *tout entier pair supérieur à 3 peut s'écrire comme une somme de nombres premiers* pour tous les entiers inférieurs à 1000.\n",
    "Développer cela dans un script appelé `goldbach.py` ce script doit avoir une fonction chapeau qui appelle toutes les autres pour pouvoir utiliser le module `timeit` en ligne de commande et benchmarker nos développements.\n",
    "\n",
    "- Attention aux commentaires\n",
    "- Attention aux noms de variables.  \n",
    "*Faites valider votre script ainsi que son exécution*. "
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***\n",
    "## Les décorateurs\n",
    "\n",
    "Un décorateur peut exécuter une routine avant et/ou après une fonction.\n",
    "Ils peuvent utiliser les arguments passés à cette dernière."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Décorateurs sans arguments\n",
    "\n",
    "Ils peuvent utiliser une valeur déjà déclarée à l'extérieur de la fonction :"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:53.148434Z",
     "start_time": "2024-10-25T15:36:53.140383Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Décorateur sans argument inspiré de https://python.doctor/page-decorateurs-decorator-python-cours-debutants\n",
    "\n",
    "user = \"olivier\"\n",
    "\n",
    "\n",
    "def mon_decorateur(fonction):\n",
    "    def autre_fonction():\n",
    "        print(\"Action refusée\")\n",
    "\n",
    "    if user != \"olivier\":\n",
    "        return autre_fonction\n",
    "\n",
    "    return fonction\n",
    "\n",
    "\n",
    "@mon_decorateur\n",
    "def do_that():\n",
    "    print(\"Execution des instructions\")\n",
    "\n",
    "\n",
    "do_that()"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution des instructions\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Décorateur avec arguments\n",
    "\n",
    "Mais avec `functools` et son wrapper, ils peuvent aussi prendre ceux de la fonction décorée :"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:53.227234Z",
     "start_time": "2024-10-25T15:36:53.195913Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import time\n",
    "from functools import wraps\n",
    "from math import sqrt\n",
    "\n",
    "\n",
    "# Décorateur avec arguments\n",
    "def timer(func):\n",
    "    @wraps(func)\n",
    "    def timeit_wrapper(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        total_time = end_time - start_time\n",
    "        print(f'Function {func.__name__}{args} {kwargs} Took {total_time:.4f} seconds')\n",
    "        return result\n",
    "\n",
    "    return timeit_wrapper\n",
    "\n",
    "\n",
    "@timer\n",
    "def fibonacci(n):\n",
    "    \"\"\"\n",
    "    Compute the n-th Fibonacci number\n",
    "    \n",
    "       :param n: The n-th Fibonacci number to compute, type int\n",
    "       :return: n-th Fibonacci number \n",
    "    \"\"\"\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fibonacci(n - 1) + fibonacci(n - 2)\n",
    "\n",
    "\n",
    "@timer\n",
    "def is_prime(n):\n",
    "    \"\"\"\n",
    "    n is the number to be check whether it is prime or not\n",
    "    \n",
    "       :param n: The number to be checked, type int\n",
    "       :return: A boolean, True if n is prime, False otherwise\n",
    "    \"\"\"\n",
    "    prime_flag = 0\n",
    "\n",
    "    if n > 1:\n",
    "        for i in range(2, int(sqrt(n)) + 1):\n",
    "            if n % i == 0:\n",
    "                prime_flag = 1\n",
    "                break\n",
    "        if prime_flag == 0:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "fibonacci(10)\n",
    "\n",
    "is_prime(23438545412552424235452557522453354357674555425)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0004 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(6,) {} Took 0.0006 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0004 seconds\n",
      "Function fibonacci(7,) {} Took 0.0011 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0001 seconds\n",
      "Function fibonacci(4,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0004 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(6,) {} Took 0.0007 seconds\n",
      "Function fibonacci(8,) {} Took 0.0018 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(6,) {} Took 0.0005 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0003 seconds\n",
      "Function fibonacci(7,) {} Took 0.0009 seconds\n",
      "Function fibonacci(9,) {} Took 0.0027 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(6,) {} Took 0.0005 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0003 seconds\n",
      "Function fibonacci(7,) {} Took 0.0009 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0003 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0001 seconds\n",
      "Function fibonacci(4,) {} Took 0.0004 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(5,) {} Took 0.0005 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(3,) {} Took 0.0001 seconds\n",
      "Function fibonacci(1,) {} Took 0.0000 seconds\n",
      "Function fibonacci(0,) {} Took 0.0000 seconds\n",
      "Function fibonacci(2,) {} Took 0.0000 seconds\n",
      "Function fibonacci(4,) {} Took 0.0002 seconds\n",
      "Function fibonacci(6,) {} Took 0.0007 seconds\n",
      "Function fibonacci(8,) {} Took 0.0016 seconds\n",
      "Function fibonacci(10,) {} Took 0.0044 seconds\n",
      "Function is_prime(23438545412552424235452557522453354357674555425,) {} Took 0.0000 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***\n",
    "### Passage d'arguments avec splat `*`\n",
    "\n",
    "### Passage d'un nombre indéterminé d'arguments\n",
    "\n",
    "Après, les arguments positionnels et les kwargs, on peut passer un nombre infini d'arguments qui se retrouveront sous forme de liste\n",
    "dans la variable préfixée par `*`. Par convention cette dernière est le plus souvent appelé args."
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-29T22:08:30.250541Z",
     "start_time": "2024-10-29T22:08:30.248078Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def multiply(*args):\n",
    "    res = 1\n",
    "    for i in args:\n",
    "        res = res * i\n",
    "    return res\n",
    "\n",
    "\n",
    "print(\"10 * 10 * 10 font:\", multiply(10, 10, 10))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 * 10 * 10 font: 1000\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Passage d'un nombre indéterminé de *keyword arguments*\n",
    "\n",
    "Les *keyword arguments* placés à la fin, après les arguments positionnels, les *keyword arguments*, les `*args` vus plus haut, se retrouvent sous forme de dictionnaire dans une variable préfixée par `**`. Par convention cette dernière est le plus souvent appelé `kwargs`."
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-29T22:15:48.732786Z",
     "start_time": "2024-10-29T22:15:48.730139Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def afficher_recette(recette, **ingredients):  # ingrédients sera un dictionnaire\n",
    "    print(recette)\n",
    "    for ingredient in ingredients.items():\n",
    "        print(\" - %s: %s\" % ingredient)\n",
    "\n",
    "\n",
    "afficher_recette(\n",
    "    \"Jambon beurre\",\n",
    "    Pain=\"frais\",  # on doit donner le nom de ce paramètre\n",
    "    Jambon=\"cuit\",\n",
    "    beurre=\"pas trop\"\n",
    ")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jambon beurre\n",
      " - Pain: frais\n",
      " - Jambon: cuit\n",
      " - beurure: pas trop\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***\n",
    "### Fonction avec tous les types d'arguments\n",
    "\n",
    "Les différents arguments doivent être dans le bon ordre :"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-29T22:18:16.168765Z",
     "start_time": "2024-10-29T22:18:16.165924Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def affichage_hybride(\n",
    "        parametre_normal,\n",
    "        parametre_avec_default=\"valeur par défaut\",\n",
    "        *args,\n",
    "        **kwargs\n",
    "):\n",
    "    print(parametre_normal)\n",
    "    print(parametre_avec_default)\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "\n",
    "\n",
    "affichage_hybride(\"param1\", \"param2\", \"infini1\", \"infini2\", kwinfini1=1, kwinfini2=2)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "param1\n",
      "param2\n",
      "('infini1', 'infini2')\n",
      "{'kwinfini1': 1, 'kwinfini2': 2}\n"
     ]
    }
   ],
   "execution_count": 9
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}