1_python_language.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction au language python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Dans cette section, nous allons:\n",
    "* Découvrir l'environnement de développement en Python pour le calcul scientifique\n",
    "* Se familiariser avec le language Python\n",
    "\n",
    "Cette section est adaptée des Scipy lecture notes [\"Getting started with Python for science\"](http://www.scipy-lectures.org/intro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'environnement de développement en Python pour la programmation scientifique\n",
    "\n",
    "### Les modules Python pour la programmation scientifique\n",
    "\n",
    "Pour obtenir un environnement de programmation scientifique, Python peut être combiné avec les modules de base suivants:  \n",
    "* [Numpy](http://www.numpy.org/): permet la définition et la manipulation de tableaux N-dimensionnel.  \n",
    "* [Scipy](http://www.scipy.org/): contient des routines haut niveau de traitement de données (optmisation, regression, interpolation, ...). \n",
    "* [Matplotlib](http://matplotlib.org/): contient des outils de visualisation.  \n",
    "\n",
    "De nombreux autres modules sont disponibles en fonction des besoins, tels que [scikit-learn](http://scikit-learn.org/stable/) pour le machine learning, [Pillow](https://python-pillow.org/), [OpenCV](http://opencv.org/), ou [scikit-image](http://scikit-image.org/) pour le traitement d'image, ... \n",
    "\n",
    "\n",
    "### Comment préparer votre environnement de travail Python?\n",
    "\n",
    "[Anaconda](https://www.continuum.io/downloads) est une distribution Python qui inclut plus de 400 packages python pour la programmation scientifique. C'est une façon pratique pour installer et mettre en place son environnement de travail sous n'importe quel système d'exploitation.  \n",
    "Les [packages](http://conda.pydata.org/docs/using/pkgs.html) et les [environnements](http://conda.pydata.org/docs/using/envs.html) peuvent être gérés avec la commande `conda` (`conda --help` et `conda env --help`). \n",
    "  \n",
    "Une autre solution est: \n",
    "1. installer Python, puis les packages nécessaires pour gérer les packages python ([Setuptools](https://pythonhosted.org/setuptools/) et [pip](https://pip.pypa.io/en/stable/)).  \n",
    "[Lien](http://docs.python-guide.org/en/latest/starting/installation/) sur comment faire une installation propre de Python en fonction de son système d'exploitation.\n",
    "2. de gérer ses environnement virtuels avec [virtualenv](https://virtualenv.pypa.io/en/latest/) et [virtualenvwrapper](http://virtualenvwrapper.readthedocs.io/en/latest/). \n",
    "\n",
    "\n",
    "La plupart des **éditeurs de texte** pour la programmation fournissent au moins un support rudimentaire pour Python. Deux options populaires sont [sublime](https://realpython.com/blog/python/setting-up-sublime-text-3-for-full-stack-python-development/) et [vim](https://realpython.com/blog/python/vim-and-python-a-match-made-in-heaven/).\n",
    "\n",
    "### Python 2 ou Python 3?\n",
    "\n",
    "D'après le [wiki Python](https://wiki.python.org/moin/Python2orPython3): \"Short version: Python 2.x is legacy, Python 3.x is the present and future of the language\".  \n",
    "\n",
    "\n",
    "### Comment exécuter du code?\n",
    "\n",
    "1. Python  \n",
    "`$ python script.py`\n",
    "\n",
    "2. IPython: shell interactif   \n",
    "`$ ipython`  \n",
    "REPL model. Très pratique pour tester des algorithmes, explorer des données,... [Documentation ici](http://ipython.readthedocs.io/en/stable/).  \n",
    "\n",
    "3. Jupyter notebook  \n",
    "Application web qui permet de créer des documents contenant du code, du texte, et des visualisations.  \n",
    "Utilise le kernel IPython. [Documentation ici](http://jupyter-notebook.readthedocs.io/en/latest/)   \n",
    "\n",
    "### Quelques astuces pour l'utilisation de IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IPython a un ensemble de \"fonctions magiques\":\n",
    "* \"Line magics\" qui ont pour préfixe le signe % et reçoivent comme argument le reste de la ligne\n",
    "* \"Cell magics\" qui ont pour préfixe le signe %% et reçoivent comme argument la cellule.\n",
    "\n",
    "Les \"magics\" incluent:\n",
    "* des fonctions en relation avec du code: `%run`, `%debug`, `%load_ext`, ...  \n",
    "* des fonctions qui affectent le shell: `%colors`, `%automagic`, `%matplotlib inline`, ...  \n",
    "* d'autres fonctions telles que `%reset`, `%timeit`, `%%writefile`, `%paste`, `%whos`, `%hist`, ...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Les bases du langage Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les types de bases\n",
    "\n",
    "#### 1. Les types numériques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérations arithmétiques de base `+`, `-`, `*`, `/`, `%` (modulo) sont implémentées nativement.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention à la division d'entier!**\n",
    "\n",
    "En Python 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par contre, en python 3, on aurait obtenu 5.5... Pour être tranquille, il vaut mieux utiliser des floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour toujours obenir le comportement de Python 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La division d'entier est obtenue avec `//`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Les containeurs\n",
    "\n",
    "**Attention l'indexage commence à 0**  \n",
    "\n",
    "##### 2.2 Les listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing fait référence à la syntaxe `semaine[start:stop:stride]` (tous les paramètres du slicing sont optionnels), cela permet d'extraire une partie de la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les éléments d'une liste peuvent avoir des types différents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour ajouter ou enlever des éléments d'une liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour concaténer et répéter une liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour trier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La notation semaine.method() (`comme semaine.append()`, `semaine.sort()`) est un exemple de la programmation orientée objet. Comme `semaine` est une `list`, elle a la méthode `xxx` appelée avec la notation `.`.\n",
    "\n",
    "Pour découvrir les méthodes disponibles, on peut utiliser la tab-completion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.2 Les strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un string est un object immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formattage des strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.3 Les dictionnaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.4 Les tuples\n",
    "\n",
    "Les tuples sont des listes immutables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.4 Les sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L'assignement\n",
    "\n",
    "**Attention: un object peut avoir plusieurs noms attachés**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les structures de contrôle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **If/elif/else structure**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **for loop**\n",
    "\n",
    "On peut itérer en utilisant un index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assez souvent, il est préférable d'itérer sur des valeurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut itérer sur n'importe quelle séquence (string, listes, keys d'un dictionnaire, lignes d'un fichier, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut utiliser `enumerate` pour obtenir l'indice et la valeur correspondante de la séquence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut itérer sur un dictionnaire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour itérer sur deux objects en parallèle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice: Compter le nombre d'occurences de chaque charactère dans la chaîne de caractères \"HelLo WorLd!!\" On renverra un dictionaire qui à la lettre associe son nombre d'occurences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"HelLo WorLd!!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**\"List comprehension\"**: une façon \"pythonesque\" de générer une liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **while condition**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'expression `break`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'expression `continue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice: Calculer une approximation de π par la formule de Wallis:\n",
    "![Wallis](wallis.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque: par défaut, les fonctions renvoient `None`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour utiliser comme input des variables optionnelles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:** si une valeur d'input d'une fonction est \"immutable\", elle ne va pas être modifiée par la fonction. Par contre, si elle est \"mutable\", il se peut qu'elle soit modifiée, comme dans l'exemple ci-dessous:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque:** Les fonctions sont des **objects**, qui peuvent:\n",
    "* être assignées à une variable  \n",
    "* un élément d'une liste  \n",
    "* être utilisée comme argument d'une autre fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'import des modules se fait en tête d'un script Python. Il est recommandé d'importer en premier les modules qui sont le plus bas niveau. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**On peut aussi créer des modules.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ensuite utiliser ce module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a alors accès aux objets du module (variables, fonctions et classes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afin d'exécuter du code directement quand un module est chargé, on peut utiliser **`__main__`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice: implémenter quicksort\n",
    "\n",
    "La [page wikipedia](https://en.wikipedia.org/wiki/Quicksort) décrivant l’algorithme de tri quicksort donne le pseudo-code suivant:\n",
    "```\n",
    "function quicksort('array')\n",
    "   if length('array') <= 1\n",
    "        return 'array'\n",
    "   select and remove a pivot value 'pivot' from 'array'\n",
    "   create empty lists 'less' and 'greater'\n",
    "   for each 'x' in 'array'\n",
    "       if 'x' <= 'pivot' then append 'x' to 'less'\n",
    "       else append 'x' to 'greater'\n",
    "   return concatenate(quicksort('less'), 'pivot', quicksort('greater'))\n",
    "```\n",
    "Transformer ce pseudo-code en code valide Python.\n",
    "\n",
    "Des indices:\n",
    "* la longueur d’une liste est donnée par `len(l)`\n",
    "* deux listes peuvent être concaténées avec `l1 + l2`\n",
    "\n",
    "Attention: une liste est mutable...\n",
    "\n",
    "Il vous suffit de compléter cette ébauche:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def quicksort(ll):\n",
    "    # ...\n",
    "    return \n",
    "\n",
    "quicksort([-2, 3, 5, 1, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les classes\n",
    "\n",
    "* Les classes sont les éléments centraux de la programmation orientée objet.\n",
    "* Classe: structure qui sert à représenter un objet et l'ensemble des opérations qui peuvent êtres effectuées sur ce dernier.\n",
    "\n",
    "Dans Python une classe contient des attributs (variables) et des méthodes (fonctions). Elle est définie de manière analogue aux fonctions mais en utilisant le mot clé class. La définition d'une classe contient généralement un certain nombre de méthodes de classe (des fonctions dans la classe).\n",
    "\n",
    "* Le premier argument d'un méthode doit être self: argument obligatoire. Cet objet self est une auto-référence.\n",
    "* Certains noms de méthodes ont un sens particulier, par exemple :  \n",
    "  * __init__: nom de la méthode invoquée à la création de l'objet  \n",
    "  * __str__ : méthode invoquée lorsque une représentation de la classe sous forme de chaîne de caractères est demandée, par exemple quand la classe est passée à print  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:** différence entre la définition d'un attribut de la classe et son instantiation à la création de la classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice: Définir une classe `Satellite()` qui permette d'instancier des objets simulant des satellites artificiels lancés dans l'espace, autour de la terre. \n",
    "\n",
    "Le constructeur de cette classe initialisera les attributs d'instance suivants, avec les valeurs par défaut indiquées:   \n",
    "* masse = 100 \n",
    "* vitesse = 0  \n",
    "\n",
    "Lorsque l'on instanciera un nouvel objet `Satellite()`, on pourra choisir son nom, sa masse et sa vitesse. \n",
    "\n",
    "Les méthodes suivantes seront définies : \n",
    "* `impulsion(force, duree)` permettra de faire varier la vitesse du satellite. La variation de vitesse \n",
    "${\\displaystyle \\Delta v}$ subie par un objet de masse $m$ soumis à l'action d'une force $F$ pendant un temps $t$ vaut $${\\displaystyle \\Delta v={\\frac {F\\times \\Delta t}{m}}}$$\n",
    "Par exemple : un satellite de 300 kg qui subit une force de 600 Newtons pendant 10 secondes voit sa vitesse augmenter (ou diminuer) de 20 m/s. \n",
    "* `affiche_vitesse()` affichera le nom du satellite et sa vitesse courante. \n",
    "* `energie()` renverra au programme appelant la valeur de l'énergie cinétique du satellite. L'énergie cinétique ${\\displaystyle E_{c}}$ se calcule à l'aide de la formule $${\\displaystyle E_{c}={\\frac {1}{2}}mv^{2}}$$ \n",
    "\n",
    "\n",
    "Exemples d'utilisation de cette classe :\n",
    "```\n",
    ">>> s1 = Satellite('Zoé', masse =250, vitesse =10)\n",
    ">>> s1.impulsion(500, 15)\n",
    ">>> s1.affiche_vitesse()\n",
    "vitesse du satellite Zoé = 40 m/s.\n",
    ">>> print s1.energie()\n",
    "200000\n",
    ">>> s1.impulsion(500, 15)\n",
    ">>> s1.affiche_vitesse()\n",
    "vitesse du satellite Zoé = 70 m/s.\n",
    ">>> print s1.energie()\n",
    "612500\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}