path: root/PVCM/cama/fr/ma1 Jupyter.ipynb

{
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "# Utilisation de Jupyter\n",
    "\n",
    "#### Cellules\n",
    "\n",
    "Une feuille Jupyter est composée de cellules que vous pouvez deviner si vous cliquez sur le texte. Il existe différents\n",
    "types de cellules que l'on choisit avec le menu déroulant au milieu des icônes en haut de la page :\n",
    "\n",
    "* du code Python (par défaut)\n",
    "* du texte enrichi ([Markdown](https://en.wikipedia.org/wiki/Markdown))\n",
    "* du texte brut (utile pour désactiver une cellule de code)\n",
    "\n",
    "Vous pouvez ajouter\n",
    "une cellule avec le symbole + en haut de la page, supprimer une cellule avec les ciseaux, déplacer une cellule avec les flèches et l'éditer en double-cliquant dessus. On verra qu'on exécute les cellules pour obtenir le résultat du code écrit. Tout cela se retrouve dans le menu\n",
    "`Cell`.\n",
    "\n",
    "#### Noyau (kernel)\n",
    "\n",
    "Jupyter tient son nom de 3 langages à savoir Julia, Python et R. Aujourd'hui la liste des langages que l'on peut\n",
    "utiliser dans une feuille Jupyter est bien plus longue mais dans tous les cas il faut un noyau qui fasse l'interface\n",
    "entre Jupyter et le langage. Dans le cas de Python le noyau est iPython. On le choisit à la création de la feuille\n",
    "et on peut interagir dessus à l'aide du menu `Kernel`. \n",
    "\n",
    "Les autres menus sont plus classiques et ne demandent pas d'explication (oubliez `Widget`).\n",
    "\n",
    "#### Note\n",
    "\n",
    "Si vous ne connaissez pas Python ni Jupyter, il est conseillé de revenir ici après avoir lu le <a href=\"../lesson1 Python basics/\">premier chapitre</a>.\n",
    "\n",
    "## Manipulation des cellules\n",
    "\n",
    "#### Etat et exécution\n",
    "\n",
    "* Une cellule peut avoir 3 états :\n",
    "     * pas sélectionnée (pas de cadre autour de la cellule)\n",
    "     * sélectionnée (cadre bleu ou barre bleue à gauche)\n",
    "     * sélectionnée et en mode édition (changement de la couleur du fond et parfois cadre vert)\n",
    "* Cliquer selectionne une cellule (voire la passe directement en mode édition pour les cellules de calcul)\n",
    "* Double cliquer selectionne et passe en mode édition (sur une zone de texte, la syntaxe Markdown apparait)\n",
    "* <kbd>Enter</kbd> comme cliquer permet de descendre dans les états quand <kbd>Esc</kbd> permet d'en remonter. \n",
    "* Pour que Python recalcule le résultat d'une cellule\n",
    "     * <kbd>Shift</kbd>+<kbd>Enter</kbd> fait le calcul et passe à la cellule suivante\n",
    "     * <kbd>Crtl</kbd>+<kbd>Enter</kbd> fait le calcul et reste sur la cellule\n",
    "     * <kbd>Alt</kbd>+<kbd>Enter</kbd> fait le calcul et ajoute une cellule vide ensuite.\n",
    "\n",
    "#### Affichage \n",
    "  \n",
    "  * `[out]` Pour ne pas afficher de résultat, finir la dernière ligne de la cellule avec `;`.\n",
    "  * `[In]` Pour ne pas afficher une cellule, utiliser 'Hide input' de nbextessions (cf config dans le menu Edit).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2)\n",
    "1+1;   # remove the ; to see the difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## Configuration\n",
    "\n",
    "Jupyter dispose de nombreuses commandes pour manipuler sa feuille de note et bien sûr il est possible de\n",
    "définir des raccourcis clavier.\n",
    "\n",
    "Pour afficher la liste des commandes (la *palette de commandes*) cliquer sur le petit clavier dans la barre d'icones.\n",
    "Avec Chrome, on peut afficher cette palette de commandes avec <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>P</kbd>.\n",
    "\n",
    "Pour afficher et définir ses raccourcis clavier vous pouvez passer le menu d'aide ou taper `shortcut` dans\n",
    "la palette de commandes.\n",
    "\n",
    "Par exemple, pour mon usage j'ai redéfini le changement de type de cellule avec\n",
    "\n",
    "* <kbd>Crtl</kbd>+<kbd>1</kbd> pour le mode Code\n",
    "* <kbd>Crtl</kbd>+<kbd>2</kbd> pour le mode Markdown\n",
    "* <kbd>Crtl</kbd>+<kbd>3</kbd> pour le mode Raw (données non interprétées)\n",
    "\n",
    "Cela fonctionne lorsque la cellule est sélectionnée mais pas en mode édition (donc cadre bleu ou barre bleue)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### Exercice \n",
    "\n",
    "Choisir ses raccourcis pour passer d'un mode à un autre puis passer la cellule ci-dessous en mode Code et l'exécuter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "print('$qsD!Me+nsodd= 1l lre3W$'[-2:2:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Les raccourcis de manipulation des cellules sont bons à connaitre ou à redéfinir lorsqu'on commence à utiliser Jupyter sérieusement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## IPython\n",
    "\n",
    "Lorsqu'on utilise Python dans Jupyter, on s'appuie sur [IPython](https://ipython.org/) qui enrichit Python.\n",
    "\n",
    "Cela donne les fonctionnalités suivantes :\n",
    "\n",
    "* Complétion en appuyant sur <kbd>Tab</kbd>\n",
    "* Aide avec `?` et `??` pour encore plus d'aide pour les objets (voire le code)\n",
    "* [Accès au shell](https://ipython.readthedocs.io/en/stable/interactive/shell.html) avec `!`\n",
    "* Les commandes magiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "### Complétion et aide\n",
    "\n",
    "`a`<kbd>Tab</kbd> va donner une liste dont `abs`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Pour les exemples d'aide il faut lancer les cellules pour voir le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Pour fermer la fenêtre d'aide cliquer sur la croix en haut à droite de la fenêtre ou utiliser <kbd>Esc</kbd>.?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mot = \"Coucou\"\n",
    "mot.split?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "### Shell sous IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vlib = '/var/lib/'\n",
    "res = !ls $vlib\n",
    "res = res.grep('lib')\n",
    "for f in res:\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(res))\n",
    "res??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "### Commandes magiques\n",
    "\n",
    "Les commandes magiques améliorent l'usage de Python. Elles commencent par \n",
    "\n",
    " * `%` et s'appliquent à la ligne\n",
    " * `%%` et s'appliquent à la cellule (lorsque cela a un sens)\n",
    "\n",
    "La première commande magique à lancer est `%quickref` pour avoir la liste des possibilités d'iPython."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%quickref"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Voici une selection de quelques commandes magiques :\n",
    "    \n",
    "* `%time` pour avoir le temps que prends la ligne (`%%time` pour le temps d'exécution de la cellule).\n",
    "* `%timeit` est comme `%time` mais il relance plusieur fois la ligne pour avoir une estimation plus juste \n",
    "* `%prun` pour lancer la ligne à travers le profiler de Python et voir où ca prend du temps\n",
    "\n",
    "* `%matplotlib inline` pour que les graphiques s'affichent dans la page Jupyter\n",
    "* `%load` pour charger un ficher Pyhton dans la cellule (met %load en commentaire un fois exécuté)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!echo 'print(\"coucou\")' > /tmp/prog.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load /tmp/prog.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.linalg as lin\n",
    "\n",
    "%prun lin.solve(np.random.random([3000,3000]), np.random.random(3000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "{{ PreviousNext('Introduction.ipynb','../lesson1 Python basics/00 - Premiers calculs.ipynb') }}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}