Découverte_Jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Découverte des Jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous lisez ce texte, c'est un bon départ, vous avez réussi à ouvrir un Jupyter notebook ! \n",
    "\n",
    "Oui ça mérite un apéro mais je vous propose d'attendre un peu celui du Lycée :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Comment ça marche ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un Jupyter notebook est un document qui mélange du texte et des cellules de code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Premier exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici ci-dessous une première cellule de code.<br/>\n",
    "On peut exécuter son contenu en mettant le curseur de la souris dans la cellule de code puis en cliquant sur `Exécuter` dans la barre de tâche ou en appuyant sur `Maj + Entrée`.\n",
    "\n",
    "<img src='barre_outils.jpeg'>\n",
    "\n",
    "Exécute le code de la cellule suivante pour avoir une information cruciale en remplaçant `???` par l'heure actuelle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Il reste 120 min avant l'apéro.\n"
     ]
    }
   ],
   "source": [
    "def avant_apero(heure):\n",
    "    \"\"\"\n",
    "    heure : à entrer de la forme 'hh:mm'\n",
    "    return : le nombre de minutes avant l'apéro\n",
    "    \"\"\"\n",
    "    temps = (int(heure[0:2])) * 60 + int(heure[3:]) \n",
    "    return 12 * 60 - temps\n",
    "\n",
    "print(\"Il reste\", avant_apero(???), \"min avant l'apéro.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Deuxième exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un notebook permet d'utiliser les codes saisis dans les cellules successives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On définit ci-dessous la fonction `carre` recevant un paramètre `x` et qui renvoie le carré de ce nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def carre(x):\n",
    "    return x ** 2\n",
    "\n",
    "carre(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut utiliser la fonction précédente pour tracer sa représentation graphique en utilisant la fonction `rep_graph` qui :\n",
    "- reçoit en paramètres une fonction `f` et deux réels `xmin` et `xmax`;\n",
    "- trace la représentation graphique de la fonction `f` sur $[x_{min},x_{max}]$ (**on peut même taper du LaTex !!**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def rep_graph(f, xmin, xmax):\n",
    "    \"\"\"\n",
    "    Fonction qui trace la représentation graphique d'une fonction f sur [xmin,xmax] \n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = []\n",
    "    pas = (xmax - xmin) / 100\n",
    "    abscisse = xmin\n",
    "    for _ in range(101):\n",
    "        x.append(abscisse)\n",
    "        y.append(f(abscisse))\n",
    "        abscisse += pas\n",
    "    plt.plot(x, y)\n",
    "    plt.show()\n",
    "    \n",
    "# Compléter ci-dessous le code pour tracer la représentation graphique de la fonction carré sur [-2,2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Comment créer un Jupyter notebook ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Comment créer un nouveau notebook ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depuis la page d'accueil de Jupyter; cliquer sur `nouveau` puis choisir `Python 3` comme ci-dessous :\n",
    "\n",
    "<img src='nouveau.jpeg'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Comment rédiger en markdown ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme pour le code que l'on exécute, le texte est saisi dans des cellules.<br/> \n",
    "Pour oberver le code utilisé pour taper le texte, il suffit de double cliquer sur le texte. Le texte brut apparait alors. Pour obtenir à nouveau la mise en forme, cliquer sur `Exécuter` dans la barre de tâche ou en appuyant sur `Maj + Entrée`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    \n",
    "<strong style=\"color: darkorange\"> Comment Jupyter distingue les cellules de code et de texte ? </strong>\n",
    "\n",
    "Quand le curseur est dans une cellule, on peut définir si la cellule est une cellule de code ou une cellule qui reçoit du texte.\n",
    "\n",
    "<img src='barre_outils.jpeg'>\n",
    "\n",
    "Ce choix se fait grâce au menu déroulant présent présent dans la barre d'outils :\n",
    "* pour du code, choisir `Code` (étonnant non ?);\n",
    "* pour du texte, choisir `Markdown`. \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La syntaxe du Markdown est assez simple, voici quelques exemples utiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les titres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `# Titre niveau 1`: définit un titre de niveau 1\n",
    "\n",
    "* `## Titre niveau 2`: définit un titre de niveau 2\n",
    "\n",
    "* `### Titre niveau 3`: définit un titre de niveau 3 \n",
    "...\n",
    "\n",
    "Plus le niveau de titre est grand plus la taille des caractères est petite."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quelques mises en forme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `**texte en gras**` : met en gras le texte présent entre les doubles **\n",
    "\n",
    "* `*texte en italique*` : met en italique le texte présent entre les *\n",
    "\n",
    "* `` `code` `` : met le texte sur un fond gris avec des caractères à chasse fixe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les listes non numérotées on utilise la syntaxe :\n",
    "\n",
    "    * item 1\n",
    "    * item 2\n",
    "    \n",
    "Pour les listes numérotées on utilise la syntaxe :\n",
    "\n",
    "    1. item 1\n",
    "    2. item 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les formules de maths !\n",
    "Tout se tape en LaTex :) :) :) : $\\displaystyle \\int_0^1 x^2 \\textrm{d}x = \\cfrac{1}{3}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Et les tableaux ?\n",
    "\n",
    "Voici un exemple. Pour voir la syntaxe, double cliquer sur la cellule.\n",
    "\n",
    "|colonne 1|colonne 2|\n",
    "|--------|--------|\n",
    "|    A    |    B    |\n",
    "|    C    |    D    |\n",
    "\n",
    "#### Pour insérer des images \n",
    "\n",
    "On utilise la syntaxe `<img scr='nom_fichier'>`. Le fichier doit être présent dans le même dossier que le fichier jupyter utilisé.\n",
    "\n",
    "\n",
    "#### Pour compléter ces instructions de bases, consulter les sites suivants :\n",
    "- [Premier lien](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/markdown/)\n",
    "- https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Comment rendre utilisable un Jupyter par les élèves ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour rendre les Jupyter notebook accessibles aux élèves, il existe plusieurs solutions :\n",
    "\n",
    "- **La première** : Installer EduPython 2.7 qui intègre un serveur Jupyter.\n",
    "- **La seconde** : Editer le Jupyter au format pdf ou html comme ci-dessous :<br/>\n",
    "Pour exporter le notebook faire `Fichier > Télécharger au format` puis choisir le format pdf ou html.\n",
    "\n",
    "- **La troisième** : Mettre le Jupyter notebook en ligne à l'aide de https://mybinder.org\n",
    "Pour cela, il faut\n",
    "    * Stocker le notebook sur le dépôt GitHub : https://github.com/.\n",
    "        * Commencer par créer un compte sur GitHub (un compte gratuit est très largement suffisant).\n",
    "        * Ensuite, un petit tuto est disponible ici.\n",
    "    * Lier le dépôt GitHub à mybinder à partir de l'adresse https://mybinder.org\n",
    "        * En copiant l'adresse du dépôt GitHub à l'emplacement **(1)**.\n",
    "        * En cliquant sur `launch` **(2)**.\n",
    "        * Le Jupyter notebook est accessible à tous ceux ayant le lien **(3)**.\n",
    "        * **Si le dépôt est modifiée avec de nouveaux fichiers les 3 étapes précédentes sont à renouveler.**\n",
    "    \n",
    "    <img src='mybinder.jpeg'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. A vous de jouer !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deux options :\n",
    "* **Option 1** : Jouer avec la suite de Héron avec un exemple de Jupyter notebook : `Heron.ipynb`\n",
    "* **Option 2** : Taper votre propre TP sous la forme d'un Jupyter Notebook."
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}