01-generalites.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "3b548cc0-a831-4599-9483-9618a86ed0ac"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Généralités\n",
    "\n",
    "![](fig/python-logo.png)\n",
    "\n",
    "*Contenu sous licence [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programme du cours\n",
    "\n",
    "### Généralités\n",
    "\n",
    "- Prise en main des notebooks\n",
    "- Généralités sur le langage Python\n",
    "\n",
    "### Le langage [1/2]\n",
    "\n",
    "- Variables\n",
    "- Types de données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "39e829af-be05-4904-996c-88b75be00f3a"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Le langage [2/2]\n",
    "\n",
    "- Opérateurs\n",
    "- Structures de contrôle\n",
    "- Fonctions\n",
    "- Exceptions et gestionnaires de contexte\n",
    "- Compréhensions de listes & expressions génératrices\n",
    "- Modules\n",
    "- Bonnes pratiques\n",
    "- Python 3.x vs 2.x\n",
    "- Le Zen de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "39e829af-be05-4904-996c-88b75be00f3a"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Microprojet\n",
    "\n",
    "###  Introduction à Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "ba13ca33-4f16-4582-9e53-0781cd19aab5"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Prise en main des notebooks\n",
    "\n",
    "Le document que vous lisez est un [notebook Jupyter](http://jupyter.org/). Il est constitué de cellules comportant :\n",
    "\n",
    "- soit du texte en [**Markdown**](https://daringfireball.net/projects/markdown/) comme ici.\n",
    "- soit du code Python, comme dans la cellule suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "cdcded0b-d241-4745-a9ca-0f41a30ffb25"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "cdba0847-ba24-4284-b6c9-04c358f5a798"
    }
   },
   "source": [
    "> **Note :**\n",
    "- [`print()`](https://docs.python.org/3/library/functions.html#print) est une fonction fournie par python pour afficher du texte à destination de l'utilisateur.\n",
    "- `In [ ]:` indique le nombre d'exécutions de la cellule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "2cbac21a-9085-4495-ab03-f926662fb3b0"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Les deux modes du notebook :\n",
    "\n",
    "- *Commande* : permet de se déplacer d'une cellule à l'autre et d'exécuter les cellules\n",
    "- *Edition* : permet de modifier le contenu d'une cellule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "955b5327-0388-44c9-b8ff-36e0e7f33268"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Changement de mode\n",
    "\n",
    "- *Commande* -> *Edition* : touche &#8629; ou double-clic dans la cellule.\n",
    "- *Edition* -> *Commande* :\n",
    "    - Touche `Esc`\n",
    " pour basculer sans exécuter\n",
    "    - Touches &#8679; + &#8629; pour *exécuter* la cellule et passer à la suivante. Exécuter une cellule en Markdown provoque le rendu visuel de celle-ci."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "dd4ecd7d-8dd6-4567-9cc7-7fcc56be2af7"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> **Exercice** : Revenez en arrière, sélectionnez et exécutez (&#8679; + &#8629;) la cellule de code qui contient\n",
    ">\n",
    "> ```python\n",
    "> print('Hello world!')\n",
    "> ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "713bce18-da20-48be-9a8c-3ab7ab2c8a0c"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mode Commande\n",
    "\n",
    "- On se déplace à l'aide des flèches $\\uparrow \\downarrow$ ou en cliquant avec la souris.\n",
    "- On peut ajouter, effacer, déplacer, créer ou modifier le contenu des cellules à l'aide des menus déroulants en haut de la page \n",
    "\n",
    "\n",
    "### Mode Edition\n",
    "\n",
    "- on entre dans le mode édition avec la touche &#8629; ou par un double-clic\n",
    "- signalement par la petite icône \"crayon\" en haut à droite, dans la barre de menu\n",
    "- on en sort avec `Ctrl` + &#8629; (ou &#8679; + &#8629; pour passer à la cellule suivante)\n",
    "\n",
    "### Note :\n",
    "\n",
    "La plupart des actions à la souris peuvent se faire à l'aide des raccourcis du menu *Help > Keyboard Shortcuts* (touche `H`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4fefd35f-1449-4c81-b342-c73932f862f6"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> **Exercice** : Revenez en arrière, sélectionnez la cellule ``print('Hello world!')``. Modifiez son contenu, par exemple en traduisant le message en français. Réexécutez-la et observez le nouveau résultat. Remarquez que le nombre d'exécutions augmente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Autres commandes utiles\n",
    "\n",
    "- Redémarrer le kernel Python : Bouton correspondant ou touche `0,0` en mode *Commande*\n",
    "- Changer le type de cellule: *Code* -> *Markdown* : touche `M` en mode *Commande*\n",
    "- Changer le type de cellule: *Markdown* -> *Code* : touche `Y` en mode *Commande*\n",
    "- Ajouter une nouvelle cellule au dessus de l'actuelle: touche `A` (pour above) en mode *Commande*\n",
    "- Ajouter une nouvelle cellule en dessous de l'actuelle: touche `B` (pour below) en mode *Commande*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> **Exercice**\n",
    "> 1. Suivre le tour guidé de l'interface : *Help > User Interface Tour*\n",
    "> 2. Avancer dans le notebook avec &#8679; + &#8629;\n",
    "> 3. Passer du mode **Commande** au mode **Edition** de différentes façons\n",
    "> 4. Ouvrez la rubrique **Keyboard Shortcuts** de l'aide et tenter de reproduire les actions uniquement avec les touches du clavier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4d300073-d045-4897-b27c-62317ab54ee4"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Notes :\n",
    "\n",
    "- Vous pouvez vous servir de votre copie d'un notebook pour faire office de bloc-notes : vous pouvez rajouter des cellules de texte pour vos commentaires et des cellules de code pour vos essais de résolution d'exercices.\n",
    "- `Ctrl` + `S` pour sauver vos modifications\n",
    "\n",
    "> **Exercice** :\n",
    "> 1. Ajoutez une cellule de texte ci-dessous (touches `B` puis `M`) et insérez une note.\n",
    "> 2. Ajoutez une cellule de code ci-dessous (touche `B`) et insérez un exemple de code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "57aa3fee-d3f9-447a-beb3-5cd90a074987"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](fig/python-logo.png)\n",
    "\n",
    "## Le langage Python\n",
    "\n",
    "- Langage interprété, originellement écrit en C\n",
    "- Open-source, portable et disponible sur Unix, Windows, MacOS, etc.\n",
    "- Syntaxe claire et simple\n",
    "- Orienté objet\n",
    "- Types nombreux et puissants\n",
    "- Interfaces avec de nombreux autres langages et librairies\n",
    "- Large spectre d'applications\n",
    "\n",
    "Plus d'informations sur [wikipedia](https://fr.wikipedia.org/wiki/Python_%28langage%29) ou sur le site officiel de [python](https://www.python.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "02af73b2-7482-49b2-891a-d94678a16d96"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Historique\n",
    "\n",
    "La genèse du langage date de la fin des années 80. [Guido van Rossum](https://fr.wikipedia.org/wiki/Guido_van_Rossum), alors à l'Institut de Recherche en Mathématiques et Informatique Hollandais ([CWI](http://www.cwi.nl)) à Amsterdam a publié la version 0.9.0 de l'interpréteur en Février 1991. Il travaille maintenant pour dropbox après 7 ans chez google.\n",
    "\n",
    "> - Plus d'histoire sur [wikipedia](https://en.wikipedia.org/wiki/History_of_Python).\n",
    "> - L'histoire racontée par le créateur lui-même sur [son blog](http://python-history.blogspot.fr) sous forme d'anecdotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "2d119a6d-dd56-4a55-9e50-fc7a4526a482"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Qu'est-ce qu'un langage interprété ?\n",
    "\n",
    "- Ordinateur $\\rightarrow$ CPU $\\rightarrow$ jeu d'instructions (ISA) $\\rightarrow$ langage binaire\n",
    "- Un langage de programmation permet d'écrire des programmes dans des langages mieux adaptés aux humains, mais nécessite une étape de traduction.\n",
    "- Comme pour une langue étrangère, il nous faut un traducteur ou un interprète...\n",
    "    - Le traducteur va lire le texte et en produire une version dans la langue étrangère.\n",
    "    - L'interprète va lire le texte, et pendant sa lecture, effectuer la traduction en direct.\n",
    "- Pour un langage informatique, c'est quasiment pareil, nous avons des [compilateurs](https://fr.wikipedia.org/wiki/Compilateur) et des [interpréteurs](https://fr.wikipedia.org/wiki/Interpr%C3%A8te_(informatique))\n",
    "    - Les compilateurs, traduisent tout le code source en langage binaire utilisable directement par le CPU.\n",
    "    - L'interpréteur lit une partie du code source et exécute directement les instructions binaires qui correspondent et passe à la suite."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "e2009051-348f-49cc-b513-96cb8d87310d"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Un langage interprété sera souvent moins rapide qu'un langage compilé, car les optimisations sont plus faciles a réaliser lors d'une compilation.\n",
    "\n",
    "Cette différence a tendance a s'estomper avec l'apparition des techniques suivantes:\n",
    "\n",
    "- [JIT](https://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e): compilation à la volée (Just In Time compilation)\n",
    "- [RTTS](https://en.wikipedia.org/wiki/Run-time_algorithm_specialisation): spécialisation de types au moment de l'exécution (Run Time Type Specialization)\n",
    "\n",
    "Une autre possibilité pour contourner la lenteur d'exécution d'un langage est de faire appel à des bibliothèques externes programmées dans un langage compilé et optimisées. C'est très efficace pour les parties du code qui sont utilisées de manière répétitive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "f480ce86-02a6-4537-ba14-c3e768a09040"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![](fig/compile_interprete.png)\n",
    "\n",
    "<span style=\"font-size:0.7em;\">Figure inspirée du livre [Apprendre à programmer en Python](http://framasoft.net/IMG/pdf/python_notes-2.pdf) de G. Swinnen.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "b0726d0e-680f-432d-abcf-764e5781af07"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Quelques interpréteurs Python\n",
    "\n",
    "- [CPython](https://www.python.org) : Implémentation de référence\n",
    "- [Jython](http://www.jython.org) : Java byte code, accès aux classes java\n",
    "- [IronPython](http://ironpython.net) : CLR byte code, accès aux classes [.NET](https://en.wikipedia.org/wiki/.NET_Framework)\n",
    "- [Pyjamas](http://pyjs.org) : JavaScript, Ajax, [GWT](http://www.gwtproject.org)\n",
    "- [Stackless Python](http://www.stackless.com) : pas de pile, microthreads, coroutines\n",
    "- [Shed Skin](http://shedskin.github.io) : C++, typage statique\n",
    "- [Cython](http://cython.org) : C, compilateur créant des modules python\n",
    "- [Pyrex](http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex) : langage proche de python, C\n",
    "- [Unladen Swallow](https://code.google.com/p/unladen-swallow) : origine google, JIT, [LLVM](http://llvm.org)\n",
    "- [Pypy](http://pypy.org) : JIT, RTTS, RPython $\\rightarrow$ C, Java byte code, CLR byte code\n",
    "- [Nuitka](http://nuitka.net/pages/overview.html) : C, fortement compatible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "5bcc3731-5f29-41ba-85f5-35c2c356dafd"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exécution d'un programme Python\n",
    "\n",
    "### Dans la console Python interactive\n",
    "\n",
    "On peut exécuter le code directement à l'invite de l'interpréteur.\n",
    "\n",
    "```python\n",
    "$ python\n",
    "Python 3.5.2+ (default, Sep 22 2016, 12:18:14)\n",
    "[GCC 6.2.0 20160927] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> a = 2\n",
    ">>> print(a)\n",
    "2\n",
    ">>>\n",
    "```\n",
    "\n",
    "### Note\n",
    "\n",
    "Le caractère `$` est l'invite de commande typique d'un système d'exploitation linux, si vous utilisez une version de windows, l'invite de commande de cmd.exe sera plutot `C:\\\\>`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "3acfd840-35dd-4a97-a01e-f9c6d2f56e13"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Depuis la console système\n",
    "\n",
    "On peut l'exécuter en paramètre de la ligne de commande\n",
    "\n",
    "```bash\n",
    "$ python -c 'a=3;print(a)'\n",
    "```\n",
    "\n",
    "Sous windows:\n",
    "\n",
    "```\n",
    "C:\\> python.exe -c 'a=3;print(a)'\n",
    "```\n",
    "\n",
    "On peut exécuter un fichier (par exemple test.py) contenant notre code\n",
    "\n",
    "```bash\n",
    "$ python test.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "1527dcfa-ae79-473b-a559-0ae9750f9762"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut exécuter directement un fichier python contenant notre code, grâce à l'utilisation du mode script avec, en rajoutant en première ligne du fichier:\n",
    "\n",
    "```python\n",
    "#! python\n",
    "```\n",
    "\n",
    "Après avoir rendu le fichier exécutable\n",
    "\n",
    "```bash\n",
    "$ chmod a+x test.py\n",
    "```\n",
    "\n",
    "Ensuite il peut être exécuté sans le précéder par le nom de l'interpréteur :\n",
    "\n",
    "```bash\n",
    "$ ./test.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "988d8020-4265-46ee-9144-eb8672f05dd4"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dans la console iPython\n",
    "\n",
    "Le terminal interactif [iPython](http://ipython.org) peut s'utiliser comme alternative à la console Python classique pour ses fonctionnalités :\n",
    "\n",
    "- syntaxe additionnelle\n",
    "- complétion\n",
    "- commandes système\n",
    "- historique enrichi\n",
    "\n",
    "Aperçu du terminal `ipython` :\n",
    "\n",
    "```ipython\n",
    "$ ipython\n",
    "Python 3.6.2 |Anaconda custom (x86_64)| (default, Sep 21 2017, 18:29:43) \n",
    "Type 'copyright', 'credits' or 'license' for more information\n",
    "IPython 6.4.0 -- An enhanced Interactive Python. Type '?' for help.\n",
    "\n",
    "In [1]: \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "cc508fe5-54ba-49f5-a40c-86a2d1889104"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Un exemple d'utilisation\n",
    "\n",
    "Sauvegarde de l'historique des commandes avec la *magic function* ``%save``\n",
    "\n",
    "```ipython\n",
    "$ ipython\n",
    "[...]\n",
    "\n",
    "In [1]: print('- Hello world!')\n",
    "- Hello world!\n",
    "\n",
    "In [2]: R = 'Hello you! '\n",
    "\n",
    "In [3]: print(R*6)\n",
    "Hello you! Hello you! Hello you! Hello you! Hello you! Hello you! \n",
    "\n",
    "In [4]: %save hello.py 1-3\n",
    "The following commands were written to file `hello.py`:\n",
    "print('- Hello world!')\n",
    "R = 'Hello you! '\n",
    "print(R*6)\n",
    "\n",
    "In [5]: quit\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4f7dc514-3c05-4af1-93f0-87acdb4dac2b"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Au sein d'un notebook Jupyter\n",
    "\n",
    "Les cellules de type *code* vous donnent accès à une console qui inclut la plupart des fonctionnalités de la console iPython.\n",
    "\n",
    "> **Exercice :**\n",
    ">\n",
    "> 1. Exécuter la cellule de code ci-dessous et observez le résultat\n",
    "> 2. Exécuter cette cellule une deuxième fois, observez la différence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "086196ff-9abd-47f9-baad-2550692df9ac"
    }
   },
   "outputs": [],
   "source": [
    "print('- Hello world!')\n",
    "R = '- Hello you!\\n'\n",
    "print(R*6)\n",
    "%history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "eb95d6d1-c801-4c58-b9a9-04ef1e1cfbce"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Utilisation d'un IDE (Environnement de développement)\n",
    "\n",
    "Un grand nombre d'IDE sont disponibles pour Python (cf. la [revue wikipedia](https://en.wikipedia.org/wiki/Comparison_of_integrated_development_environments#Python) et la [revue wiki.python.org](https://wiki.python.org/moin/IntegratedDevelopmentEnvironments)).\n",
    "\n",
    "Citons simplement :\n",
    "\n",
    "- [**IDLE**](https://docs.python.org/3/library/idle.html) : l'IDE par défaut de Python.\n",
    "- [**Spyder**](https://github.com/spyder-ide/spyder) : l'IDE qui sera utilisé pour certains exercices de ce cours.\n",
    "- [**Pycharm**](https://www.jetbrains.com/pycharm/) : une alternative moins libre que Spyder mais avec de nombreuses fonctionnalités comme le support pour les outils de suivi de version ou la complétion automatique.\n",
    "- [**Eclipse**](https://eclipse.org) : un IDE initialement java, mais avec son système de greffons, il peut être utilisé pour d'autres langages, comme par exemple python avec [PyDev](http://pydev.org). Plus lourd que les précédents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Pourquoi un IDE ?\n",
    "\n",
    "Dans un IDE, on dispose d'outils intégrés dans une interface (généralement) intuitive :\n",
    "\n",
    "- débugueur\n",
    "- analyseur de variables\n",
    "- outils d'introspection de code\n",
    "- outils de coloration et de correction syntaxique\n",
    "- raccourcis d'exécution\n",
    "- profileurs de code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d5537f86-7704-4957-b7f3-c717e201a366"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Applications du langage Python\n",
    "\n",
    "Python est un langage complet, utilisable dans un grand nombre de domaines.\n",
    "\n",
    "###  Grand public\n",
    "\n",
    "![](fig/applications_python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d5537f86-7704-4957-b7f3-c717e201a366"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mais aussi\n",
    "\n",
    "- openstack - gestionnaire de cloud\n",
    "- yum - installeur de paquets redhat, centos\n",
    "- softimage - modelage et rendu 3D\n",
    "- maya - modelage et rendu 3D\n",
    "- paint shop pro - éditeur d'images\n",
    "- inkscape - éditeur de graphiques vectoriels\n",
    "- gnuradio - SDR (software defined radio) toolkit\n",
    "\n",
    "Et encore plus d'exemples sur [wikipedia](https://en.wikipedia.org/wiki/List_of_Python_software#Applications)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "8ad61675-f575-4fb5-abe7-6b9356f5bc32"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Intérêt pour les sciences\n",
    "\n",
    "Pour un usage scientifique, Python est intéressant à plusieurs titres. En effet, il est capable de réaliser de manière automatique et efficace un certain nombre de tâches qui sont le quotidien des scientifiques :\n",
    "- Manipuler et traiter des données de simulations ou d'expériences\n",
    "- Visualiser des résultats\n",
    "- Communiquer ses résultats sous la forme de données numériques formatées, de figures ou d'animations\n",
    "- Dans le domaine du **calcul scientifique**, Python est particulièrement riche en fonctionnalités grâce à la contribution importante de la communauté des mathématiques et du calcul à travers le projet [SciPy](http://www.scipy.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "61db19b5-8032-4fe7-a49c-67341f5395c7"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Le Python scientifique\n",
    "\n",
    "#### 1. Développement de code de simulation\n",
    "\n",
    "Bien que généralement moins performant que les langages compilés (C, C++ ou Fortran), Python est particulièrement intéressant et agréable à programmer dans les phases de développement pour tester rapidement de nouvelles méthodes. Une fois le prototypage terminé, il est possible de porter les parties critiques du code vers un langage compilé plus rapide, tout en gardant le reste en python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "12736066-06a7-40ad-a2a2-fcdc59d45fdd"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### 2. Traitement de données\n",
    "\n",
    "- langage de haut niveau produisant du code agréable à lire (par opposition à excel, par exemple...)\n",
    "- nombreux modules spécialisés (algèbre, statistique, traitement d'images, etc.)\n",
    "- le concept assez novateur des **notebooks Jupyter** qui combinent de l'exécution de code, du texte formaté, des formules mathématiques (via LaTeX), des tracés et du contenu média"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "17d447c3-086a-41c0-92e4-c3e9fe03c803"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### 3. Tracés graphiques :\n",
    "- tracés 1D, 2D voire 3D\n",
    "- animations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "f85920a4-2ef4-4744-bfc1-fa77f38094c8"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Les principaux paquets dédiés au Python scientifique :\n",
    "\n",
    "- [NumPy](http://www.numpy.org) : calcul numérique, opérations mathématiques sur tableaux et matrices de grandes dimensions\n",
    "- [SciPy](https://www.scipy.org) : ensemble d'outils scientifiques pour le traitement de signal, d'images, algèbre lineaire, etc...\n",
    "- [Sympy](http://sympy.org) and [SAGE](http://www.sagemath.org) : bibliothèques et outils mathématiques pour le calcul symbolique\n",
    "- [Matplotlib](http://matplotlib.org) : tracer et visualiser des données sous forme graphique, à la matlab ou mathematica\n",
    "- [Pandas](http://pandas.pydata.org) : analyser vos données\n",
    "- [TensorFlow](https://www.tensorflow.org/) : bibliothèque d'apprentissage machine développée par Google\n",
    "- [Scikit-learn](http://scikit-learn.org/) : apprentissage machine, fouille et analyse de données\n",
    "- [BioPython](http://biopython.org) : problèmes de biologie : génomique, modélisation moléculaire, etc...\n",
    "- [AstroPy](http://www.astropy.org) : bibliothèque communautaire dédiée à l'astronomie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4727d9c2-9c48-4d8c-8791-9795ad702bf0"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Python plutôt que Matlab ?\n",
    "\n",
    "#### Constat\n",
    "\n",
    "- On dispose ainsi d'un outil très complet et performant qui représente une alternative sérieuse aux outils commerciaux tels que Matlab, Maple, Mathematica, etc.\n",
    "- Le site [scipy-lectures](http://www.scipy-lectures.org/index.html) fournit de bons pointeurs vers les applications scientifiques de Python avec Scipy.\n",
    "\n",
    "#### Alors ?\n",
    "\n",
    "- Une discussion intéressante : [Python vs Matlab](http://www.pyzo.org/python_vs_matlab.html)\n",
    "- Un guide de migration : [Numpy for Matlab users: guide](https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html)\n",
    "- Une table de conversion de la syntaxe : [NumPy for MATLAB users: syntax](http://mathesaurus.sourceforge.net/matlab-numpy.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "caec144c-e46c-4d97-a2d0-3736fcda3f01"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Documentation et sources\n",
    "\n",
    "### La documentation\n",
    "\n",
    "- Officielle :\n",
    "  - [L'index](https://www.python.org/doc/)\n",
    "  - [La FAQ](https://docs.python.org/faq/)\n",
    "  - [La librairie standard](https://docs.python.org/3/library/index.html)\n",
    "  - [Des tutoriels](https://docs.python.org/3/tutorial/index.html)\n",
    "- [Stackoverflow](https://stackoverflow.com/questions/tagged/python) : Forum de questions / réponses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "6e89aaa8-a784-4534-aba3-1414244d2265"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Les sources de ce support\n",
    "\n",
    "Quelques ressources qui ont inspiré le contenu de ce cours et qui pourront vous servir pour aller plus loin...\n",
    "\n",
    "#### avec le langage\n",
    "\n",
    "- Le MOOC de l'INRIA : [Python 3 : des fondamentaux à l'utilisation du langage](https://www.fun-mooc.fr/courses/course-v1:UCA+107001+session02/about) hébergé sur la plateforme [FUN](https://www.france-universite-numerique-mooc.fr)\n",
    "- La formation du [groupe Calcul](http://calcul.math.cnrs.fr) : [ANF \"Python avancé en calcul scientifique\"](http://calcul.math.cnrs.fr/spip.php?rubrique102)\n",
    "- La formation de Pierre Navaro : [Python pour le calcul](https://github.com/pnavaro/python-notebooks)\n",
    "- Le livre de Gérard Swinnen : [Apprendre à programmer en Python](http://framasoft.net/IMG/pdf/python_notes-2.pdf)\n",
    "- Le cours de python scientifique de l'institut de science du téléscope spatial: [STSCI's Scientific Python Course 2015](https://github.com/spacetelescope/scientific-python-training-2015) (en anglais)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "6e89aaa8-a784-4534-aba3-1414244d2265"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### avec les notebooks Jupyter\n",
    "\n",
    "- Ce qu'on peut écrire en Markdown et en LaTeX dans les notebooks [Jupyter](http://jupyter.org/) et ce qu'on peut faire dans les cellules de code dans cette [série de tutoriels](https://www.youtube.com/playlist?list=PLRJx8WOUx5XcDMOxSQegCJUjTJePTlF9Z)\n",
    "- Pour mettre vos notebooks en ligne : [nbviewer](http://nbviewer.ipython.org), [binder](https://mybinder.org/)\n",
    "\n",
    "#### en s'entrainant\n",
    "\n",
    "- Site de tutorat social : [Python Tutor](http://pythontutor.com)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Aucun(e)",
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}