Python_intro1_variables_fonctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INTRODUCTION AU LANGAGE PYTHON appliqué au programme de 2 BCP: les variables et les fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Extrait *BO* Programme de **Mathématiques** 2 BCP domaine *Algorithmique et programmation* :\n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <th align=\"center\"><b>Capacités</th>\n",
    "    <th align=\"center\"><b>Connaissances</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Choisir ou reconnaître le type d’une variable.</td>\n",
    "    <td>Types de variables : entiers, flottants, chaînes de caractères, booléens.</td>\n",
    "  </tr>  \n",
    "    <tr>\n",
    "    <td>Réaliser un calcul à l'aide d'une ou plusieurs variables.</td>\n",
    "    <td>Affectation d'une variable.</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Comprendre et utiliser des fonctions.\n",
    "      <br>Compléter la définition d'une fonction.\n",
    "    </td>\n",
    "    <td>Arguments d'une fonction.\n",
    "      <br>Valeur(s) renvoyée(s) par une fonction.\n",
    "      </td>\n",
    "  </tr>  \n",
    "    <tr>\n",
    "    <td>Structurer un programme en ayant recours à des fonctions pour résoudre un problème donné.</td>\n",
    "    <td> </td>\n",
    "  </tr>\n",
    "</table>\n",
    "\n",
    "Ce *notebook* (document *interactif*) traite des *variables* et des *fonctions* en Python.  \n",
    "Les deux premières parties présentent les notions essentielles.  \n",
    "La troisième partie présente des exercices suggérés dans les paragraphes *Exemples d'algorithmes et d'activités numériques* du programme.   \n",
    "- **Les codes du document peuvent être complétés, testés et modifiés**. Pour celà, `clic` sur le cadre, puis `shift-enter` ou &#x27A7;`Exécuter` dans la barre d'outils ci-dessus.  \n",
    "Pour *rafraîchir* tous les codes, `Kernel` -> `Restart & Clear Output`  \n",
    "Pour *rafraîchir* un seul code (*JupyterLab*), `clic-droit` -> `Clear Outputs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LES TYPES DE DONNEES ET LES VARIABLES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les types de données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python** est un langage qui travaille avec des **objets** qui appartiennent à des **classes** .  \n",
    "Pour chaque classe, des *fonctions* ou *méthodes* spécifiques peuvent être utilisées.  \n",
    "Voici les principales classes d'objets mentionnées dans les programmes de BCP :\n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <th align=\"center\"><b>Différentes classes d'objets</th>\n",
    "    <th align=\"center\"><b> </th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><i>int</b></i></td>\n",
    "    <td>c'est la classe des <b>nombres entiers</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><i>float</b></i></td>\n",
    "    <td>c'est la classe des <b>nombres décimaux</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><i>bool</b></i></td>\n",
    "    <td>c'est la classe des <b>booléens</b> (True - False)</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td align=\"center\"><b><i>str</b></i></td>\n",
    "    <td>c'est la classe des <b>chaînes de caractères</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><i>list</b></i></td>\n",
    "    <td>c'est la classe des <b>listes d'objets</b></td>\n",
    "  </tr>    \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une **variable** est une donnée stockée dans la mémoire de l'ordinateur.  \n",
    "*Exécuter le code suivant pour afficher les résultats.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mon_age=25        #La valeur 25 est AFFECTEE à la variable mon_age (mon_age RECOIT la valeur 25)\n",
    "print(mon_age)    #Affiche la valeur de la variable\n",
    "print(mon_age+4)\n",
    "print(mon_age*2)\n",
    "type(mon_age)     #Affiche la classe de la variable\n",
    "\n",
    "#MODIFIER LE CODE AVEC UN AGE DECIMAL et observer les résultats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Affectation des variables\n",
    "a=5\n",
    "b=3\n",
    "c=a*b\n",
    "print(a,b,c)\n",
    "\n",
    "d,e=9,5\n",
    "print(d,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texte=\"Bonjour les amis !\"    #Une chaine de caractères est définie entre des doubles apostrophes \"\".\n",
    "print(texte)\n",
    "type(texte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LES FONCTIONS\n",
    "Une **fonction** permet d'exécuter un certain nombre d'instructions déjà enregistrées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quelques fonctions très utiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><i>type</b></i></td>\n",
    "      <td align=\"center\"><b>type</b>(<i>nom_de_la_variable</i>)</td>\n",
    "      <td><b>Renvoie la classe</b> de la variable.</td>  \n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td align=\"center\"><b><i>print</b></i></td>\n",
    "      <td align=\"center\"><b>print</b>(<i>valeur1, valeur2, ...</i>)</td>\n",
    "      <td><b>Affiche la valeur</b> ou les valeurs d'une ou plusieurs variables.</td>  \n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td align=\"center\"><b><i>input</b></i></td>\n",
    "      <td align=\"center\"><b>input</b>(<i>paramètre</i>)</td>\n",
    "      <td><b>Renvoie l'objet</b> saisi par l'utilisateur.</td>  \n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td align=\"center\"><b><i>int <br>float <br>str <br>bool <br>list </b></i></td>\n",
    "      <td align=\"center\"><b>int</b>(<i>paramètre</i>) <br> <b>float</b>(<i>paramètre</i>) <br> <b>str</b>(<i>paramètre</i>) <br> <b>bool</b>(<i>paramètre</i>) <br> <b>list</b>(<i>paramètre</i>)  </td>\n",
    "      <td align=\"center\"><b>Convertit la classe</b> du paramètre (en entier, nombre décimal, chaîne de caractères, booléen, liste).</td>  \n",
    "  </tr>\n",
    " <tr>\n",
    "    <td align=\"center\"><b><i>help</b></i></td>\n",
    "      <td align=\"center\"><b>help</b>(<i>paramètre</i>)</td>\n",
    "      <td><b>Affiche la documentation <i>(docstring)</i> </b> du paramètre.</td>  \n",
    "  </tr> \n",
    "    \n",
    "</table>\n",
    "\n",
    "*Exemples de codes à exécuter:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonctions input(), print() et type()\n",
    "lycee=input(\"votre lycée:\")               #La variable lycee reçoit la réponse\n",
    "ville=input(\"dans quelle ville?\")      \n",
    "print(\"Mon lycée est\", lycee, \"à\", ville)\n",
    "print(type(lycee))                        #Affiche le type de la variable lycee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonctions input(), print() et int()\n",
    "annee=input(\"votre année de naissance: \") \n",
    "annee+10                                        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A RETENIR:**  \n",
    "La fonction *input()* renvoie des objets de la classe **str** .   \n",
    "Les messages d'erreur renseignent sur l'erreur (ligne, type, ...). Ici, c'est une erreur de type (**TypeError**).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Modifier et exécuter le code précédent pour pouvoir réaliser l'opération: utiliser la fonction int() pour modifier la classe de la variable annee.*  \n",
    "Pour *rafraîchir* un seul code (*JupyterLab*), `clic-droit sur la cellule de code` -> `Clear Outputs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme calculant l'aire d'un rectangle\n",
    "l=input(\"largeur du rectangle:\")\n",
    "L=input(\"longueur du rectangle:\")\n",
    "#changement de classe des variables\n",
    "l=float(l)\n",
    "L=float(L)\n",
    "\n",
    "aire=l*L\n",
    "print(\"L'aire du rectangle est\", aire, \"cm2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Créations de fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est souvent intéressant de créer des fonctions pour les utiliser ensuite.  \n",
    "Pour créer une fonction, une syntaxe est :\n",
    "```python\n",
    "       def nom_de_la_fonction(paramètre1, paramètre2, ...) : \n",
    "           #bloc d'intructions\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction calculant l'aire d'un rectangle\n",
    "def aire_rectangle(l,L):                           #!!! NE PAS OUBLIER LES :     \n",
    "    aire=L*l                                       #!!! RESPECTER LES INDENTATIONS (espacements) DU BLOC d'instructions de la fonction\n",
    "    print(\"L'aire du rectangle est\", aire, \"cm2\")\n",
    "    \n",
    "#Test de la fonction\n",
    "aire_rectangle(5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction calculant le périmètre d'un rectangle\n",
    "def perimetre(l,L):\n",
    "    return 2*L+2*l\n",
    "\n",
    "#Test de la fonction\n",
    "a=perimetre(5,10)     #La valeur renvoyée par la fonction est affectée à la variable a.\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importation de fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions que l'on crée peuvent être sauvegardées dans des fichiers appelés **modules** .  \n",
    "Python stocke dans des **modules** des fonctions et des variables ayant un rapport entre elles.  \n",
    "Il existe un grand nombre de modules Python.  \n",
    "Plusieurs modules sont parfois regroupés dans des ***packages (ou bibilothèques)*** (= dossiers).  \n",
    "*Exemples de modules et bibliothèque utiles:*  \n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <td><b><i>math</b></i></td>\n",
    "    <td>Contient les principales fonctions mathématiques</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td><b><i>random</b></i></td>\n",
    "    <td>Permet la génération de nombres aléatoires</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td><b><i>turtle</b></i></td>\n",
    "      <td>La tortue Python, l'équivalent de <i>Scratch</i> <br>Permet de tracer des figures géométriques</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td><b><i>time</b></i></td>\n",
    "    <td>Pour l'heure, la date et chronométrer</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td><b><i>tkinter</b></i></td>\n",
    "    <td>Permet d'afficher des fenêtres graphiques</td>\n",
    "  </tr>    \n",
    "  <tr>\n",
    "    <td><b><i>matplotlib <br><i>(bibliothèque)<i/> </b></i></td>\n",
    "    <td> </td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td><b><i>numpy <br><i>(bibliothèque)<i/> </b></i></td>\n",
    "    <td> </td>\n",
    "  </tr>\n",
    "</table>\n",
    "\n",
    "Pour utiliser les fonctions et variables d'un module, il faut **importer** le module.  \n",
    "*Remarque:*  \n",
    "Une opération d'importation *crée un lien* entre votre document de travail et le module appelé qui est déjà sur votre machine. *Ce n'est pas une opération de téléchargement* .  \n",
    "Certaines bibliothèques (comme mathplotlib, numpy, ...) peuvent être absentes de votre machine et nécessitent alors un **téléchargement** par exemple via Internet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A RETENIR:**  \n",
    "Pour connaître les fonctions ou variables d'un module ainsi que leurs caractéristiques, penser à utiliser la fonction **help()** dans l'*interpéteur Python* .  \n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <td><b><i>Pour connaître les fonctions Python présentes nativement dans l'interpéteur (sans importations)</b></i></td>\n",
    "    <td><a href=\"https://docs.python.org/3/library/functions.html\">https://docs.python.org/3/library/functions.html</a></td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td><b><i>Pour connaître les modules Python présents sur votre machine</b></i></td>\n",
    "    <td>help(\"modules\")</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td><b><i>Informations sur un module</b></i></td>\n",
    "    <td>help(\"nom_du_module\")  <br>help(nom_du_module) si le module est déjà importé</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td><b><i>Informations sur une fonction d'un module</b></i></td>\n",
    "      <td>help(\"nom_du_module.nom_de_la_fonction\") <br>help(nom_du_module.nom_de_la_fonction) <br>help(nom_de_la_fonction)  si la fonction est déjà importée  </td>\n",
    "  </tr>\n",
    "</table>\n",
    "\n",
    "Taper `Q` pour quitter l'aide, `espace` pour avancer d'une page, `entrer`pour avancer d'une ligne.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exemples de recherches d'informations:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Chercher des informations sur la fonction radian du module math\n",
    "help(\"math.radians\")\n",
    "#Chercher des informations sur le module math (par exemple, pour connaître l'ensemble des fonctions du module). !!!L'exécution de cette commande peut être longue...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Chercher des informations sur le module random\n",
    "\n",
    "#Chercher des informations sur la fonction randint\n",
    "\n",
    "#Chercher des informations sur la fonction random (du module random ...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exemples d'importations de modules et d'utilisations de fonctions:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode import\n",
    "import math          #Importation du module math\n",
    "a=math.pi            #Appel de la variable pi du module math avec la syntaxe nom_du_module.nom_de_la_fonction\n",
    "b=math.sqrt(19)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode from ... import ...\n",
    "from math import radians   #Importation de la fonction radians du module math\n",
    "radians(180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Méthode from ... import *\n",
    "from random import *       #Importation de TOUTES les fonctions et variables du module random\n",
    "a=random()\n",
    "b=randint(1,6)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCICES D'APPLICATIONS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Géométrie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter les fonctions suivantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def volume_boule(r):                #Fonction renvoyant le volume d'une boule\n",
    "    from math import pi  \n",
    "    return   #Votre code\n",
    "\n",
    "#Test fonction\n",
    "a=volume_boule(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cote_carre(A):                  #Fonction renvoyant la longueur du côté d'un carré d'aire A\n",
    "    \n",
    "    #Votre code\n",
    "    #Importer la fonction renvoyant la racine carré d'un nombre\n",
    "    \n",
    "#Test fonction\n",
    "print(cote_carre(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diametre_cylindre(h,V):         #Fonction renvoyant le diamètre d'un cylindre connaissant la hauteur h et le volume V\n",
    "    \n",
    "    #Votre code\n",
    "    \n",
    "    \n",
    "#Test fonction\n",
    "print(diametre_cylindre(3,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculs commerciaux et financiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter le programme suivant renvoyant le montant d'un intérêt simple.  \n",
    "Exemple:    C0= 1000€; t=5%; n=250 jours --> I &asymp; 34,72€"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "C0: capital placé\n",
    "t: taux annuel des intérêts en %\n",
    "n: période du placement en jours\n",
    "En sortie:\n",
    "chaine de caractères présentant les intérêts I\n",
    "\"\"\"\n",
    "\n",
    "C0=float(input(\"capital placé:\"))\n",
    "t=\n",
    "n=\n",
    "\n",
    "I=        \n",
    "\n",
    "print(\"Un capital de\", C0,\"€ placé pendant\", n,\"jours au taux annuel de\", t, \"%, produit\",I,\"€ d'intérêts\")\n",
    "\n",
    "#Remarque: pour arrondir le montant des intérêts aux centimes d'euros, utiliser la fonction round() ...infos avec la fonction help()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Réaliser un programme calculant le montant net à payer après remise en % pour une facture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "PBHT: prix brut hors taxe en €\n",
    "remise: remise en %\n",
    "En sortie:\n",
    "chaine de caractères présentant le prix net HT (PNHT)\n",
    "\"\"\"\n",
    "\n",
    "#votre code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer un programme qui, à partir des données des coordonnées de deux points, renvoie l'équation réduite d'une droite non // à l'axe des ordonnées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En entrée:\n",
    "xA\n",
    "yA\n",
    "xB       On suppose xB > xA\n",
    "yB\n",
    "En sortie:\n",
    "chaine de caractères présentant l'équation réduite ou ses paramètres a et b.\n",
    "\"\"\"\n",
    "\n",
    "#Détermination du coefficient a\n",
    "#Votre code\n",
    "\n",
    "#Détermination du coefficient b\n",
    "#Votre code\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résolution d'un problème du premier degré"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une agence de location de voiture propose la formule suivante: 21€ puis 0,05€/km.  \n",
    "Compléter les fonctions suivantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prix(x):\n",
    "    \"\"\"\n",
    "    Fonction renvoyant le prix à payer en fonction du nombre de km parcourus\n",
    "\n",
    "    En entrée:\n",
    "    x: nombre de km\n",
    "    En sortie:\n",
    "    y: prix à payer en €\n",
    "    \"\"\"\n",
    "\n",
    "    #votre code\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nb_km(y):\n",
    "    \"\"\"\n",
    "    Fonction renvoyant le nombre de km à parcourir en fonction du prix en €\n",
    "\n",
    "    En entrée:\n",
    "    y: prix en €\n",
    "    En sortie:\n",
    "    x: nombre de km\n",
    "    \"\"\"\n",
    "\n",
    "    #votre code\n",
    "\n"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}