{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> TP n°3 : Initiation à Python (Les fonctions et modules)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afin de pouvoir personnaliser votre notebook Jupyter sans détruire le notebook sur lequel travaille votre voisin(e), vous allez tout d'abord aller dans le menu **`File`** (en haut) puis cliquer sur **`Make a copy...`**. Renommez le notebook avec votre nom, par exemple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les cellules des notebook Jupyter sont éditables et exécutables.\n",
    "\n",
    "Pour exécuter le contenu d'une cellule dans ce document, vous pouvez utiliser le bouton\n",
    "<button><i class=\"fa fa-step-forward\"> Exécuter</i></button> (dans le menu en haut) ou bien utiliser les combinaisons de touches suivantes :\n",
    "\n",
    "* **Shift + Enter** : le code de la cellule est exécuté et le curseur à la cellule suivante.\n",
    "* **Ctrl + Enter** : le code de la cellule est exécuté et le curseur reste sur la même cellule.\n",
    "* **Alt + Enter** : le code de la cellule est exécuté et le notebook crée une nouvelle cellule immédiatement après."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarques :</B></U></p>\n",
    "    <ul>\n",
    "        <li><p>Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton <button class='fa fa-plus icon-plus btn btn-xs btn-default'></button> (dans le menu en haut);</p>\n",
    "        <li><p>Toutes les cellules de ce notebook commençant par <B><I>Entrée [x]</I></B> sont à exécuter.</p>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Les fonctions\n",
    "\n",
    "## 1.1. Déclaration\n",
    "\n",
    "Une fonction en Python est définie en utilisant le mot-clé **`def`** suivi : du nom de la fonction, suivi par les arguments que cette fonction prend, en entrée entre parenthèse `()` et d'un double point `:`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <U>Synthaxe :</U>\n",
    "\n",
    "```python\n",
    "def  mafonction(arg1,arg2,arg3):\n",
    "    \"\"\"  Commentaire  explicatif éventuellement\n",
    "    sur  plusieurs  lignes (= docstring).\"\"\"\n",
    "    \n",
    "    instructions\n",
    "    \n",
    "    return  sortie1,sortie2, sortie3,...\n",
    "```\n",
    "\n",
    "Appel de la fonction (= utilisation dans un programme) :\n",
    "\n",
    "```python\n",
    "mafonction(x, y, z)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarque :</B></U></p>\n",
    "    <p>Une fonction peut ne prendre aucun argument en entrée (arg1, arg2, ...) et peut ne renvoyer qu'une seule donnée (nombre, booléen (True ou False), chaîne de caractèrer, etc.).</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exemple :</U>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    y = 3 * x - 2\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appel de la fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Analyse du code :</U>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exemple, on reconnaît le mot clé `def` suivie du nom de la fonction - ici **f** - suivi par les arguments que cette fonction prend en entrée entre parenthèse - ici un seul argument est pris en entrée : `x`.\n",
    "\n",
    "- Pour savoir où commence et où finit la fonction, python utilise la notion de bloc. Un bloc\n",
    "  - commence par `:`\n",
    "  - est décalé par rapport au début de la marge\n",
    "  \n",
    "Ainsi notre fonction commence à la ligne `y =`et se finit après le `return`.\n",
    "  \n",
    "On retrouve encore les fameux blocs qui commencent par `:` et qui sont **décalés par rapport à la marge** que nous avons déjà rencontré dans les tests, les boucles for, while etc... \n",
    "  \n",
    "- La ligne `y = 3 * x - 2` est assez explicite...\n",
    "- La ligne `return y` est importante : c'est elle qui indique ce que doit renvoyer la fonction.\n",
    "\n",
    "&#8594; La fonction **f** est ici un moyen rapide d'exécuter le calcul `y = 3 * x - 2` sans avoir à retaper la formule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Un autre exemple :</U>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_world():                # Cette fonction ne prend aucun argument en entrée\n",
    "    print(\"Hello World !\")        # et renvoie la phrase \"Hello World !\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appel de la fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "hello_world()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut récupérer dans une variable ce que renvoie une fonction (ce qui n'est pas possible si la fonction affiche quelque chose avec un `print` au lieu de le renvoyer avec un `return`) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parabole(x):\n",
    "    return x ** 2 - 3\n",
    "\n",
    "print(parabole(4))\n",
    "\n",
    "a = parabole( 3 )                 # Ce que renvoie la fonction parabole est stocké dans la variable a\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <U>Exercice :</U>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observer l'exemple ci-dessous et répondre aux questions posées ensuite :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def table(n,limite):\n",
    "    print(\"Table de multiplication de \", n)\n",
    "    for i in range(1, limite + 1):\n",
    "        print(i, \"x\", n, \"=\", i * n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Comment s'appelle la fonction ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Votre réponse ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Quel(s) arguments prend-elle ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Votre réponse ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Que retourne t-elle ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Votre réponse ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Que fait-elle ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Votre réponse ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Appelez cette fonction pour sortir la table de 7 pour des nombres allant de 1 à 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Modifier le code de la fonction afin qu'elle renvoie la table de la division puis appeler cette fonction pour la tester."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2. Docstring\n",
    "\n",
    "Il n'est pas obligatoire, mais fortement recommandé d'écrire une *docstring* (commentaire d'explications) qui décrit le but et le fonctionnement de la fonction. La *docstring* s'écrit directement en dessous de la définition de la fonction, avant le code de la celle-ci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x, y):\n",
    "    \"\"\"Retourne la somme des deux\n",
    "    arguments `x` et `y`.\"\"\"\n",
    "    \n",
    "    return x + y                   # renvoie le résultat du calcul x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(2, 3)                     # les arguments sont des entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition((1,2),(3,4))              # les arguments sont des tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(0.2,5)                    # les arguments sont des réels (float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3. Argument par défaut et argument par mot-clé\n",
    "\n",
    "On peut également écrire des fonctions avec des arguments par défaut, ce qui signifie que si l'argument n'est pas renseigné lors de l'appel de la fonction, une valeur par défaut sera utilisée. La valeur par défaut d'un argument définit en rajoutant un signe `=` après le nom de ce dernier, dans le signature de type de la fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_fonction(a, b = 1, verbose = False):                # b et verbose ont des arguments par défaut\n",
    "    if verbose:                                            \n",
    "        print('Calcul de : {} x {}'.format(a, b))\n",
    "        \n",
    "    return a ** b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_fonction(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut définir explicitement la valeur d'un argument en précisant son nom lors de l'appel de la fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_fonction(2, verbose = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_fonction(verbose = True, b = 3, a = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quoi sert la variable `verbose` ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Votre réponse ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Les bibliothèques\n",
    "\n",
    "La plupart des fonctionnalités en Python sont fournies sous forme de modules regroupés dans une bibliothèque. Un module est un fichier Python, contenant un ensemble de définitions de fonctions et des déclarations de variables, mis à disposition afin de pouvoir être utilisées dans un programme sans avoir à les réécrire.\n",
    "\n",
    "Deux types de  [bibliothèques](https://fr.wikibooks.org/wiki/Programmation_Python/Biblioth%C3%A8ques_pour_Python) sont disponibles :\n",
    "\n",
    "- Les [bibliothèques stantards](https://docs.python.org/fr/3/library/index.html), distribuées avec Python est découpées en [modules](https://matplotlib.org/py-modindex.html).\n",
    "- Les bibliothèques alternatives dont les plus populaires et les plus utilisées (XML, interfaces graphiques, représentations graphiques,...) bénéficient de pages dédiées sur le site principal du langage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut importer un module en utilisant la synthaxe :\n",
    "\n",
    "```python\n",
    "import nom_module\n",
    "```\n",
    "\n",
    "Si on ne veut importer qu'une fonction d'un module, on utilise la synthaxe :\n",
    "\n",
    "```python\n",
    "from nom_module import nom_fonction\n",
    "```\n",
    "\n",
    "On peut renommer, dans un programme, un module importé ou la fonction d'un module importé en utilisant la synthaxe :\n",
    "\n",
    "```python\n",
    "import nom_module as nouveau_nom\n",
    "```\n",
    "\n",
    "```python\n",
    "import nom_module.nom_fonction as nouveau_nom\n",
    "```\n",
    "\n",
    "L'appel, dans le programme, du module (ou de la fonction) importé se fera alors avec `nouveau_nom`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. Le module `Math`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut importer le module math de la bibliothèque standard et utiliser les fonctions qui y sont définies par :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math    # importation du module math de la bibliothèque standard pour utiliser les fonctions qui y sont définies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut obtenir plus d'informations sur le module `math`soit en tapant : `help(math)`, soit en cherchant sur le web."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(math.tan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.tan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on ne souhaite pas importer le module en entier, on peut se restreindre à importer que quelques fonctions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import exp, cos, sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp(1), cos(0), sin(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besoin de plus d'information sur une fonction ? Vous pouvez vous servir de la fonction `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(atan2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-danger\" role=\"alert\" style=\"margin: 10px\">\n",
    "    <p><U><B>Remarques :</B></U></p>\n",
    "    <ul>\n",
    "        <li>\n",
    "            <p>Lorsque l'on importe un module, les fonctions (ou méthodes) du module sont accessibles en tapant : <code>module.fonction()</code>. Or, si on importe directement une fonction avec la syntaxe : <code>from nom_module import nom_fonction</code> On peut s'affranchir du &laquo; <code>module.</code> &raquo;, mais au risque de conflits de noms avec les fonctions déjà présentes dans le programme.</p>\n",
    "        </li>\n",
    "        <br>\n",
    "        <li>    \n",
    "            <p>On peut importer tout un module grâce à au symbole <code>*</code> qui signifie &laquo; tout &raquo;.</p>\n",
    "        </li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <U>Exemple :</U>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tan(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tan(x):\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tan(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(tan(1))\n",
    "except:\n",
    "    print(\"La fonction tan n'a pas encore été importée !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. Autre modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe de nombreux modules dans la bibliothèque standard de Python. D'autre bibiliothèque sont disponibles en téléchargement.\n",
    "\n",
    "Dans l'activité sur les représentations graphiques, on découvrira le module **Numpy** et le module **Matplotlib**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <U>Exercice n°1 :</U>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implémenter en Python une fonction qui compte le nombre de voyelles (minuscules, sans accents) dans une chaîne de caractères `chaine` passée en argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ici ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <U>Exercice n°2 :</U>\n",
    "\n",
    "En mathématiques, on utilise la fonction ***factorielle*** d'un nombre pour calculer le produit de tous les entiers non nuls entre 1 et ce nombre.\n",
    "\n",
    "<U>Par exemple :</U>\n",
    "\n",
    "Factorielle 5 ( que l'on note 5! ) se calcule par la formule : $5!=1\\times 2\\times 3\\times 4\\times 5=120$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implémenter en Python une fonction **`factorielle`**, à l'aide d'une boucle **`for`**, prenant en argument un entier et retournant la valeur de $n!$ ayant la signature (nom) suivante : \n",
    "```python\n",
    "    def factorielle(n):\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette activité s'inspire très largement de :\n",
    "- cours de [Antony Lesage](https://www.lptmc.jussieu.fr/user/barbi/ENSEIGNEMENT/M2/Python1617/TD01-Exercices/TD01-Introduction_%D0%95_Python.html)\n",
    "- MOOC [Bioinformatique : algorithmes et génomes sur FUN](https://www.fun-mooc.fr/courses/course-v1:inria+41003+session03/about)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}