01_04_Fonctions_et_Modules_en_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce bootcamp, nous avons déjà utilisé plusieurs fonctions. Voici quelques exemples:\n",
    "* input()\n",
    "* type()\n",
    "* int()\n",
    "* str()\n",
    "* print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les `fonctions` sont des bouts de codes qui ont une fonctionalité précises et sont déjà écrites pour nous et sauvegardées dans des fichiers python qu'on appelle `module`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetons un coup d'oeil à quelques fonctions: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les fonctions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `replace` permet de remplacer une partie d'une chaine de caractères:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bonjour Python'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello Python\".replace('Hello', 'Bonjour')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dit que les entrées \"Hello\" et \"Bonjour\" sont des paramètres de la fonction replace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons d'écrire nos propres fonctions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La syntaxe d'une fonction est la suivante:\n",
    "```python\n",
    "def nom_de_la_fonction(paramètres):\n",
    "    code qui explique ce que fait la fonction\n",
    "    return quelque chose\n",
    "```\n",
    "Le mot clé `def` dit à python que le code indenté ci-dessous est une fonction et le mot clé `return` permet de retourner le résultat de la fonction. On peut avoir plusieurs `return` dans une fonction mais dès qu'un est éxécuté, la fonction est terminée . Une fonction ne retourne pas forcément quelque chose. Dans ces cas, on peut simplement ommetre le mot clé return.\n",
    "\n",
    "\n",
    "Ecrivons une fonction qui prend en entrée un nombre et nous retourne s'il est pair ou impair :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def est_pair(nombre):\n",
    "    if nombre % 2 == 0: # si reste de la division de nombre par 2 est 0\n",
    "        return True     # retourne Vrai et fonction terminée\n",
    "    return False # sinon retourne Faux et fonction terminée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "resultat = est_pair(5)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "resultat = est_pair(8)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrivons une autre fonction qui retourne un message de salutation personnalisé à chaque utilisateur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def salutation(nom):\n",
    "    message = f\"Bonjour {nom}. J'espère que vous passez une bonne journée\"\n",
    "    return message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Bonjour Bob. J'espère que vous passez une bonne journée\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salutation(\"Bob\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Bonjour Kévin. J'espère que vous passez une bonne journée\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salutation(\"Kévin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrivons une autre fonction `grandir` qui prend 2 paramètres le nom et l'age de l'utilisateur et ajoute une année à l'âge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grandir(nom, age):\n",
    "    message = f'Bonjour {nom}, vous avez grandi. Vous avez désormais {age + 1} ans'\n",
    "    return message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bonjour Bob, vous avez grandi. Vous avez désormais 16 ans'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = grandir('Bob', 15)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous avez dû remarqué qu'on définit des variables au sein d'une fonction. Ces variables appartiennent à la fonction dans laquelle elles ont été crée. On parle de **variable locale**. Contrairement les variables définies en dehors des fonctions sont appelées **variable globale** et sont accessibles même à l'intérieur des fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def essaie(n):\n",
    "    variable_locale = n + 1\n",
    "    print(variable_locale)\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "essaie(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'variable_locale' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-1ac45272934c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvariable_locale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'variable_locale' is not defined"
     ]
    }
   ],
   "source": [
    "variable_locale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variable_globale = 2\n",
    "\n",
    "def essaie(n):\n",
    "    m = n + variable_globale # variable_globale accessible\n",
    "    return m\n",
    "\n",
    "essaie(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python vient avec un nombre enorme de fonctions utiles. Ces fonctions sont dans un fichier python comme par exemple `os.py`. On peut importer ces fonctions tout simplement avec le mot clé **import**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module os permet d'interagir avec notre système d'opération, donc de copier, créer, déplacer, supprimer des fichiers et documents grâce à des focntions dédiées. Importons le module os:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut afficher les fichiers dans ce dossier grâce à la fonction `listdir()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.ipynb_checkpoints',\n",
       " '.github',\n",
       " '.git',\n",
       " '01_07_Exercices_sur_les_bases_de_python.ipynb',\n",
       " 'images',\n",
       " 'README.md',\n",
       " '.gitignore',\n",
       " '01_05_Manipuler_les_fichiers_en_Python.ipynb',\n",
       " 'datasets',\n",
       " '01_06_Programmation_orientee_object_avec_Python.ipynb',\n",
       " 'LICENSE',\n",
       " '01_02_Input_et_Conditions.ipynb',\n",
       " '02_Introduction_au_calcul_numerique_avec_Python.ipynb',\n",
       " '01_04_Fonctions_et_Modules_en_Python.ipynb',\n",
       " '01_03_Les_Boucles_en_Python.ipynb',\n",
       " '01_01_Les_Types_de_Variables_en_Python.ipynb',\n",
       " '03_Manipulation_des_donnees_avec_Pandas.ipynb']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir('./') # le chemin relatif du dossier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['count.txt', 'movie.csv']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir('./datasets')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction nous retourne une liste des fichiers et dossiers présents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un autre module intéressant est le module **random** qui permet de générer des nombres aléatoires. Ici nous utiliserons la fonction `randint` qui génère un nombre aléatoire dans un intervalle donné. On peut l'importer différement cette fois ci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randrange(0, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut créer notre propre module juste en créant un fichier python nommée `salut.py` dans le même dossier que celui-ci et y mettre notre fonction **salutation** et y avoir accès de cette manière:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from salut import salutation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Bonjour Kevin. J'espère que vous passez une bonne journée\""
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "salutation('Kevin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour plus d'explication sur les modules, Référez-vous à la vidéo qui accompagne cette vidéo sur la chaine Youtube: youtube.com/c/kevindegila.\n",
    "\n",
    "Pour pratiquer vos nouvelles compétences sur les fonctions, vous pouvez commencer ici : https://www.w3schools.com/python/exercise.asp?filename=exercise_functions1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}