Fonction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fonctions\n",
    "\n",
    "Dans un programme, il est possible d’écrire des petits sous programmes intermédiaires appelés fonctions.\n",
    "Une fonction porte un nom et peu comporter une ou plusieurs variables appelées paramètres.\n",
    "\n",
    "#### Exemple 1 :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x**2-3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pour définir une fonction on utilise l'instruction `def Nom_de_la_fonction(paramètre):`. Dans le cas précédent, le nom de la fonction est `f` et la fonction admet un paramètre nommé `x`.\n",
    "\n",
    "* **Attention à ne pas oublier les `:` ainsi que l'indentation pour toutes les instructions internes à la fonction.**\n",
    "\n",
    "* L'instruction `return` permet de renvoyer la valeur de la fonction à la fin de son exécution.\n",
    "\n",
    "* On remarque que si on exécute la fonction \"dans son cadre\", il ne se passe rien. Pour la tester, il faut l'appeler avec dune valeur pour le paramètre. Taper le code `f(5)` dans le cadre ci-dessous puis faite tourner le programme. Tester également d'autre valeurs pour le paramètre.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemple 2 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PlusGrand(a,b,c):\n",
    "    max=a\n",
    "    if max<b:\n",
    "        max=b\n",
    "    if max<c:\n",
    "        max=c\n",
    "    return max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction prend trois nombres comme paramètre et renvoie le plus grand de ces trois nombres. \n",
    "\n",
    "Tester cette fonction plusieurs fois dans le cadre suivant.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remarque : \n",
    "\n",
    "Evidemment, on peut également utiliser une fonction dans un programme plus conséquent comme nous le verrons par la suite.\n",
    "\n",
    "#### Exercice : \n",
    "La fonction suivante vérifie si 3 nombres entiers forment un triplet Pytharoricien (le premier\n",
    "nombre entré devant être le plus grand).\n",
    "1. Appeler cette fonction avec plusieurs valeurs (5,4,3) par exemple ou (5,4,4).\n",
    "2. Quelle retour donne la fonction ? Essayer d'expliquer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Reciproque(a,b,c):\n",
    "    return a**2==b**2+c**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Reciproque(10,5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remarque :\n",
    "La fonction renvoie le résultat d'un test qui vrai `True` ou faux `False`. Ce type de réponse correspond au variables appellées **variables booléennes**.\n",
    "\n",
    "#### Exercice :\n",
    "1. Faites tourner la fonction `Reciproque()` pour les valeurs (10,8,6), puis pour les valeurs (6,8,10).\n",
    "2. Que remarque-t-on ? Justifier.\n",
    "3. Ecrire un programme qui demande trois nombres entiers (sans contrainte sur l'ordre) et qui \"dit\" si ces nombres forment un triplet Pythagoricien. \n",
    "*Evidemment, on utilisera  les fonctions `PlusGrand()` et `Reciproque()`.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer le premier nombre : 3\n",
      "Entrer le deuxième nombre : 4\n",
      "Entrer le troisième nombre : 5\n",
      "Le triangle est rectangle.\n"
     ]
    }
   ],
   "source": [
    "nombre1=input('Entrer le premier nombre : ')\n",
    "nombre1=float(nombre1)\n",
    "nombre2=input('Entrer le deuxième nombre : ')\n",
    "nombre2=float(nombre2)\n",
    "nombre3=input('Entrer le troisième nombre : ')\n",
    "nombre3=float(nombre3)\n",
    "if PlusGrand(nombre1,nombre2,nombre3)==nombre1:\n",
    "    booleen=Reciproque(nombre1,nombre2,nombre3)    \n",
    "elif PlusGrand(nombre1,nombre2,nombre3)==nombre2:\n",
    "    booleen=Reciproque(nombre2,nombre1,nombre3)\n",
    "else:\n",
    "    booleen=Reciproque(nombre3,nombre2,nombre1)\n",
    "\n",
    "if booleen:\n",
    "    print('Le triangle est rectangle.')\n",
    "else:\n",
    "    print('Le triangle n''est pas rectangle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice :\n",
    "Écrire un programme qui détermine les triplets Pythagoricien dont la longueur des cotés est inférieure à 100.\n",
    "\n",
    "*Comme vous vous en doutez, ce programme necessite au moins une boucle... voir deux ou trois les unes dans les autres.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 , 4 , 5\n",
      "5 , 12 , 13\n",
      "6 , 8 , 10\n",
      "7 , 24 , 25\n",
      "8 , 15 , 17\n",
      "9 , 12 , 15\n",
      "9 , 40 , 41\n",
      "10 , 24 , 26\n",
      "11 , 60 , 61\n",
      "12 , 16 , 20\n",
      "12 , 35 , 37\n",
      "13 , 84 , 85\n",
      "14 , 48 , 50\n",
      "15 , 20 , 25\n",
      "15 , 36 , 39\n",
      "16 , 30 , 34\n",
      "16 , 63 , 65\n",
      "18 , 24 , 30\n",
      "18 , 80 , 82\n",
      "20 , 21 , 29\n",
      "20 , 48 , 52\n",
      "21 , 28 , 35\n",
      "21 , 72 , 75\n",
      "24 , 32 , 40\n",
      "24 , 45 , 51\n",
      "24 , 70 , 74\n",
      "25 , 60 , 65\n",
      "27 , 36 , 45\n",
      "28 , 45 , 53\n",
      "28 , 96 , 100\n",
      "30 , 40 , 50\n",
      "30 , 72 , 78\n",
      "32 , 60 , 68\n",
      "33 , 44 , 55\n",
      "33 , 56 , 65\n",
      "35 , 84 , 91\n",
      "36 , 48 , 60\n",
      "36 , 77 , 85\n",
      "39 , 52 , 65\n",
      "39 , 80 , 89\n",
      "40 , 42 , 58\n",
      "40 , 75 , 85\n",
      "42 , 56 , 70\n",
      "45 , 60 , 75\n",
      "48 , 55 , 73\n",
      "48 , 64 , 80\n",
      "51 , 68 , 85\n",
      "54 , 72 , 90\n",
      "57 , 76 , 95\n",
      "60 , 63 , 87\n",
      "60 , 80 , 100\n",
      "65 , 72 , 97\n"
     ]
    }
   ],
   "source": [
    "for i in range (1,101):\n",
    "    for j in range (i,101):\n",
    "        for k in range (j,101):\n",
    "            if Reciproque(k,j,i):\n",
    "                print(i,',',j,',',k)\n",
    "    "
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}