2019-2020/1ST/Programmation/2-Fonctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python et fonctions\n",
    "\n",
    "Le but de ce TP est de découvrir les fonctions en programmation.\n",
    "\n",
    "* [Echauffement](#Que-fait-ce-programme?)\n",
    "* [Fonctions mathématiques](#Fonctions-mathématiques)\n",
    "* [Faire beaucoup de calculs](#Faire-beaucoup-de-calculs)\n",
    "* [Reçut/Recalé/mentions au bac](#Reçut/Recalé/mentions-au-bac)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Que fait ce programme?\n",
    "\n",
    "* Copier puis coller le programme, l'executer. Fait-il ce que vous attendiez de lui?\n",
    "* Commenter au dessus de chaque ligne (avec #...) pour expliquer ce qu'elle fait."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entree1 = 'Choux'\n",
    "entree2 = 'Salade'\n",
    "plat1 = 'Frites'\n",
    "plat2 = 'Haricots vert'\n",
    "print(\"==== Menu du jour ====\")\n",
    "print(\"\")\n",
    "print(\"Entrées -----\")\n",
    "print(\" * \", entree1)\n",
    "print(\" * \", entree2)\n",
    "print(\"Plats -------\")\n",
    "print(\" * \", plat1)\n",
    "print(\" * \", plat2)\n",
    "print(\"\")\n",
    "print(\"Faites votre choix\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ajouter un choix de dessert à ce programme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonctions mathématiques \n",
    "\n",
    "On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n",
    "\n",
    "Cette fonction polynôme\n",
    "\n",
    "$$ f:x \\mapsto -x^2 + 6x+ 3$$\n",
    "\n",
    "se codera en python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return -x**2+6*x-3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que la fonction est codée, on peut l'utiliser pour calculer des images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f(10))\n",
    "print(f(-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier les commandes précédentes pour calculer d'autres images. Vous pouvez aussi entourer le résultat du calcul avec une phrase pour décrire le résultat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour chacune des fonctions suivantes, testées les pour savoir si elles fonctionnents. Une fois que vous ètes sûr qu'elles font bien ce que vous souhaitez, ne les effacées pas et gardez les pour la suite.\n",
    "\n",
    "* Programmer la fonction $g$ définie par \n",
    "    $$ g:x \\mapsto x(19 - 2x) $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer des images par cette fonction et vérifier que les résultats correspondent bien à que l'on attend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "* Programmer la fonction $h$ qui correspond au programme de calcul suivant\n",
    "\n",
    "    * Choisir un nombre\n",
    "    * -> Ajouter 2\n",
    "    * -> Elever au carré\n",
    "    * -> Soustraire 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer des images par cette fonction et vérifier que les résultats correspondent bien à que l'on attend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "* Programmer une fonction `celcius2fahrenheit` qui convertit des degrés celcius vers des degrés fahrenheit en utilisant la formule suivante\n",
    "    $$ (°F) = 1,8 * (°C) + 32 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convertir en Fahrenheit les températures suivantes\n",
    "$$\n",
    "        0°C \\qquad 10°C \\qquad 100°C\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Programmer la fonction inverse `fahrenheit2celcius`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convertir en Celsius les températures suivantes\n",
    "$$\n",
    "        0°F \\qquad 100°F \\qquad -10°F\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Les 2 prochaines parties peuvent être faite independament. A vous de choisir celle qui tente le plus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Faire beaucoup de calculs\n",
    "\n",
    "Imaginons que je souhaite chercher le maximum de la fonction $f$ programmée précédement. Il va falloir que je fasse calculer à python plusieurs images de cette fonction.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f(0))\n",
    "print(f(5))\n",
    "print(f(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le faire de la sorte peut prendre beaucoup de temps et se serait se priver de faire travailler l'ordinateur à notre place\n",
    "\n",
    "Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser ** une boucle ** `for`.\n",
    "\n",
    "Ici la boucle va calculer les images par la fonction $f$ de tous les nombres de 0 à 9. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(10):\n",
    "    print(\"Quand x vaut\", x, \", f(x) vaut\", f(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut donc penser que la fonction a un maximum  autour de 3.\n",
    "\n",
    "* Ecrire toutes les conversions 0 à 100 degré celcius en farhenheit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Approcher le maximum de la fonction $g$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser une boucle `while` (tant que).\n",
    "\n",
    "Ici, on va calculer les images par la fonction $f$ des nombres entre 2 et 4 avec un pas de 0,1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quand x vaut 2 f(x) vaut  5\n",
      "Quand x vaut 2.1 f(x) vaut  5.190000000000001\n",
      "Quand x vaut 2.2 f(x) vaut  5.359999999999999\n",
      "Quand x vaut 2.3000000000000003 f(x) vaut  5.51\n",
      "Quand x vaut 2.4000000000000004 f(x) vaut  5.640000000000001\n",
      "Quand x vaut 2.5000000000000004 f(x) vaut  5.75\n",
      "Quand x vaut 2.6000000000000005 f(x) vaut  5.84\n",
      "Quand x vaut 2.7000000000000006 f(x) vaut  5.91\n",
      "Quand x vaut 2.8000000000000007 f(x) vaut  5.960000000000001\n",
      "Quand x vaut 2.900000000000001 f(x) vaut  5.99\n",
      "Quand x vaut 3.000000000000001 f(x) vaut  6.000000000000002\n",
      "Quand x vaut 3.100000000000001 f(x) vaut  5.989999999999998\n",
      "Quand x vaut 3.200000000000001 f(x) vaut  5.959999999999999\n",
      "Quand x vaut 3.300000000000001 f(x) vaut  5.91\n",
      "Quand x vaut 3.4000000000000012 f(x) vaut  5.839999999999998\n",
      "Quand x vaut 3.5000000000000013 f(x) vaut  5.749999999999998\n",
      "Quand x vaut 3.6000000000000014 f(x) vaut  5.639999999999999\n",
      "Quand x vaut 3.7000000000000015 f(x) vaut  5.509999999999998\n",
      "Quand x vaut 3.8000000000000016 f(x) vaut  5.359999999999999\n",
      "Quand x vaut 3.9000000000000017 f(x) vaut  5.189999999999996\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "pas = 0.1\n",
    "while x <= 4:\n",
    "    print(\"Quand x vaut\", x, \"f(x) vaut \", f(x))\n",
    "    x = x + 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les nombreux chiffres après la virgules (qui sont faux!) viennent de la façon de stocker les nombres à virgules dans l'ordinateur. Ils sont présents dans la majorité des programmes et il est difficile de les éviter. C'est une des raison pour laquelle on ne peut pas faire aveuglément confiance à un ordinateur.\n",
    "\n",
    "* Écrire toutes les conversions de -100 à 100 degrés farhenheit vers les degrés celcius avec un pas de 10.\n",
    "* Affiner votre recherche de maximum de la fonction $g$ avec un pas de 0,1 puis de 0,01."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reçut/Recalé/mentions au bac\n",
    "\n",
    "Au bac, on applique le barème suivant:\n",
    "\n",
    "* Note strictement inférieure à 10: recalé\n",
    "* Note supérieure à 10: reçut\n",
    "\n",
    "On peut y voir une fonction qui transforme une *note* en l'un des deux mots *recalé* ou *reçut*.\n",
    "\n",
    "* Programmer cette fonction (aller voir du coté des `if` dans le mémo).\n",
    "\n",
    "Parmi les reçuts, certains peuvent avoir des mentions:\n",
    "\n",
    "* $10 \\leq note < 12 $: pas de mentions\n",
    "* $12 \\leq note < 14 $: Assez Bien\n",
    "* $14 \\leq note < 16 $: Bien\n",
    "* $16 \\leq note $: Très Bien\n",
    "\n",
    "* Programmer cette fonction qui transforme une note en la mention."
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}