Data_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installation d'un distribution Python\n",
    "\n",
    "Il existe plusieurs distributions de Python à destination des scientifiques : \n",
    "\n",
    "* [Anaconda](https://store.continuum.io/cshop/anaconda/)\n",
    "\n",
    "* [Canopy](https://www.enthought.com/products/canopy/)\n",
    "\n",
    "* [Python(x,y)](https://code.google.com/p/pythonxy/)\n",
    "\n",
    "Chacune de ces distributions est disponible pour un grand nombre d'architectures 32 et 64 bits (Linux, Windows, Mac OS...).  \n",
    "Courant 2014, Anaconda semble être l'offre la plus simple d'accès et qui offre la meilleure compatibilité multi-plateformes.\n",
    "Il s'agit de la distribution installée par défaut sur les machines de la salle de TP.\n",
    "\n",
    "## Installation de packages supplémentaires : \n",
    "\n",
    "Chacune de ces distributions comprend un ensemble de packages scientifiques (numpy, scipy, pandas...) et d'outils de développement (Spyder, Ipython). Python étant un langage ouvert, il est possible d'installer d'autres packages issus de la communauté ou de collègues. \n",
    "\n",
    "Plusieurs outils de gestion des paquets existent. Par exemple, pour installer seaborn : \n",
    "\n",
    "```bash \n",
    "pip install seaborn\n",
    "ou \n",
    "conda install seaborn (uniquement pour la distribution Anaconda)\n",
    "```\n",
    "\n",
    "Ces outils se connectent à des dépots en ligne et gèrent intégralement le téléchargement des sources et leur installation.\n",
    "\n",
    "Si un paquet n'est pas disponible dans les dépôts officiels, il existe plusieurs alternatives : \n",
    "\n",
    "* Télécharger les sources et les installer manuellement avec la commande \n",
    "\n",
    "```bash \n",
    "python setup.py install\n",
    "```\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prise en main de Spyder\n",
    "\n",
    "Spyder est un environnement graphique de développement inspiré de l'interface Matlab.\n",
    "\n",
    "<img src='spyder_.png'/>\n",
    "\n",
    "Ses fonctionnalités comprennent : \n",
    "\n",
    "* Edition et éxecution de fichiers sources\n",
    "* Exploration de fichiers et de variables\n",
    "* Profiling du code \n",
    "* Affichage de l'aide\n",
    "* Gestion des variables d'environnement\n",
    "* ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Création de fichier : \n",
    "\n",
    "* Créez un nouveau fichier en cliquant sur l'icône en haut à gauche ou avec le raccourci CTRL+N\n",
    "* Tapez \n",
    "```python \n",
    "print \"hello world\"\n",
    "```\n",
    "* Exécutez-le en tapant F5...\n",
    "* ... ou n'exécutez que la ligne en cours de sélection avec F9\n",
    "* Le résultat de l'exécution s'affiche dans la console"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "slide_helper": "subslide_end",
     "slide_type": "subslide"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# TP 1 : Types, variables et opérations de contrôle : \n",
    "\n",
    "\n",
    "Ouvrez le fichier data_type.py contenu dans l'archive avec Spyder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "print \"Hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "print '1', # la virgule empèche le saut de ligne après le print\n",
    "print '2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scalaires\n",
    "\n",
    "* Les types numériques int et float \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "internals": {},
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "a = 1  # int\n",
    "b = 1. # float\n",
    "print a\n",
    "print b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'A' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-26-6cc3eabd3eb1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Les variables sont sensibles à la casse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mA\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'A' is not defined"
     ]
    }
   ],
   "source": [
    "# Les variables sont sensibles à la casse\n",
    "print A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "internals": {
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "2\n",
      "0\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "print(1+1.)\n",
    "print 1+1\n",
    "print 1/2\n",
    "print 1./2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "internals": {
     "slide_type": "subslide"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nombres complexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "internals": {},
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "c = 1+2j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "internals": {
     "slide_helper": "subslide_end"
    },
    "slide_helper": "slide_end",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "2.0\n",
      "(1-2j)\n",
      "(-3+4j)\n",
      "(2+2j)\n"
     ]
    }
   ],
   "source": [
    "print c.real        # real et un attribut de l'objet c\n",
    "print c.imag        # imag et un attribut de l'objet c\n",
    "print c.conjugate() # Pourquoi des parenthèses ici? conjugate est une méthode de c\n",
    "print c*c\n",
    "print a+c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question : \n",
    "* **calculer le module de c **"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booléens \n",
    "Les booléens sont un sous ensemble des entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "False\n",
      "1\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print True + True  #True vaut 1, False vaut 0 \n",
    "print True & False\n",
    "print (1 | False)\n",
    "print not False\n",
    "print a == b \n",
    "print a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pourquoi \n",
    "```python \n",
    "a == b \n",
    "```\n",
    "retourne vrai alors que \n",
    "```python \n",
    "a is b \n",
    "```\n",
    "retourne faux?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test \"If\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a == 1\n"
     ]
    }
   ],
   "source": [
    "if a == 1 : \n",
    "    print \"a == 1\" # Notez les 4 espaces après le retour à la ligne.\n",
    "                   # Un groupe d'instruction est marqué par un même niveau d'indentation\n",
    "else : \n",
    "    print \"a <> 1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is an integer\n"
     ]
    }
   ],
   "source": [
    "if a == 1 : \n",
    "    if type(a) == type(1.0) : \n",
    "        print \"a is a float\"\n",
    "        \n",
    "    elif type(a) == type(1):        \n",
    "        print 'a is an integer'\n",
    "        \n",
    "else : \n",
    "    print \"a <> 1\"        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boucle \"For\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "a\n",
      "test\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,'a','test'] : \n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boucle \"While\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5: \n",
    "    i += 1 # identique à i = i + 1\n",
    "    print i "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** :\n",
    "\n",
    "* Ecrire les multiples de 7 et de 3 de 0 à 500 (utiliser l'opérateur // pour le modulo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caractères et chaînes de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "aujourd'hui\n"
     ]
    }
   ],
   "source": [
    "print \"a\"\n",
    "print 'b' # on peut aussi bien utiliser ' que \"\n",
    "print \"aujourd'hui\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le concaténation des caractères se fait avec le signe +"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab\n",
      "aaaaabbbb\n"
     ]
    }
   ],
   "source": [
    "print 'a'+'b'\n",
    "print 'a'*5+'b'*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les caractères disposent de méthodes de manipulation, remplacement et de recherche : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'n', 'n', '']\n",
      "balala\n",
      "Banana\n",
      "BANANA\n",
      "1--2--3--4\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print 'banana'.split('a')\n",
    "print 'banana'.replace('n','l')\n",
    "print 'banana'.capitalize()\n",
    "print 'banana'.upper()\n",
    "print '--'.join(['1','2','3','4'])\n",
    "print 'banana'.count('na')\n",
    "print \"Python\".find('on')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les chaînes de caractères sont en fait des listes de caractères : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "a\n",
      "t\n",
      "nnellement\n",
      "0 a\n",
      "1 n\n",
      "2 t\n",
      "3 i\n",
      "4 c\n",
      "5 o\n",
      "6 n\n",
      "7 s\n",
      "8 t\n",
      "9 i\n",
      "10 t\n",
      "11 u\n",
      "12 t\n",
      "13 i\n",
      "14 o\n",
      "15 n\n",
      "16 n\n",
      "17 e\n",
      "18 l\n",
      "19 l\n",
      "20 e\n",
      "21 m\n",
      "22 e\n",
      "23 n\n",
      "24 t\n"
     ]
    }
   ],
   "source": [
    "e = 'anticonstitutionnellement'\n",
    "print len(e)\n",
    "print e[0] # Comme en C, les listes commencent à 0\n",
    "print e[-1] # l'élément -1 est le dernier élément, le -2 l'avant dernier...\n",
    "print e[15:] # imprime tous les éléments après le 15ème\n",
    "\n",
    "for i,char in enumerate(e) :  # enumerate liste les éléments d'une liste et leur position\n",
    "    print i,char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-56-2c9bea4d62f9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0me\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'A'\u001b[0m \u001b[1;31m# les chaînes de charactères sont immutables\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "e[0] = 'A' # les chaînes de charactères sont immutables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ligne 0: Gur Mra bs Clguba, ol Gvz Crgref\n",
      "\n",
      "Ligne 1: \n",
      "\n",
      "Ligne 2: Ornhgvshy vf orggre guna htyl.\n",
      "\n",
      "Ligne 3: Rkcyvpvg vf orggre guna vzcyvpvg.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "### Lecture d'un fichier ligne par ligne : \n",
    "f = open('zen.txt','r')\n",
    "print 'Ligne 0: '+ f.readline()\n",
    "print 'Ligne 1: '+ f.readline() \n",
    "print 'Ligne 2: '+ f.readline() \n",
    "print 'Ligne 3: '+ f.readline() \n",
    "f.close() # fermeture du fichier\n",
    "# Si le fichier reste ouvert, il sera indisponible pour les autres programmes de l'OS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une version plus efficace de la lecture de fichier est d'utiliser le mot clef *with*.\n",
    "Celui-ci crée un sous bloc de code qui, quoi qu'il arrive, exécute une action avant la sortie de code.\n",
    "Utilisé en conjonction avec *open*, *with* fermera toujours le fichier en fin de code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gur Mra bs Clguba, ol Gvz Crgref\n",
      "\n",
      "Ornhgvshy vf orggre guna htyl.\n",
      "Rkcyvpvg vf orggre guna vzcyvpvg.\n",
      "Fvzcyr vf orggre guna pbzcyrk.\n",
      "Pbzcyrk vf orggre guna pbzcyvpngrq.\n",
      "Syng vf orggre guna arfgrq.\n",
      "Fcnefr vf orggre guna qrafr.\n",
      "Ernqnovyvgl pbhagf.\n",
      "Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf.\n",
      "Nygubhtu cenpgvpnyvgl orngf chevgl.\n",
      "Reebef fubhyq arire cnff fvyragyl.\n",
      "Hayrff rkcyvpvgyl fvyraprq.\n",
      "Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff.\n",
      "Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg.\n",
      "Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu.\n",
      "Abj vf orggre guna arire.\n",
      "Nygubhtu arire vf bsgra orggre guna *evtug* abj.\n",
      "Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn.\n",
      "Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.\n",
      "Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!\n"
     ]
    }
   ],
   "source": [
    "with open('zen.txt','r') as f : \n",
    "    s =  f.read()\n",
    "    print s\n",
    "    # à la fin execute f.__exit__() qui ferme le fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-243-bacd0e0f09a3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: I/O operation on closed file"
     ]
    }
   ],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion de nombres en textes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "La variable toto vaut 3.142 à l'itération 12\n"
     ]
    }
   ],
   "source": [
    "print \"%d\"%42\n",
    "print \"La variable %s vaut %2.3f à l'itération %d\"%('toto',3.14159,12.) # arguments positionnels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe une autre syntaxe qui permet des expressions plus complexes : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a, b, c\n",
      "Coordinates: 37.24N, -115.81W Zen\n"
     ]
    }
   ],
   "source": [
    "print '{0}, {1}, {2}'.format('a', 'b', 'c')\n",
    "print 'Coordinates: {latitude}N, {longitude}W {text}'.format(latitude=37.24, longitude=-115.81,text='Zen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour aller plus loin avec les chaînes de caractères : \n",
    "\n",
    "* Expressions régulières avec le module re (import re)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les listes\n",
    "\n",
    "* Ce sont des containers, c'est à dire que les listes contiennent d'autres objets, peu importe leur type.\n",
    "* Les listes sont des objets *mutables*, c'est à dire qu'elles sont modifiables après leur création "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "1\n",
      "[1, 'deux', 3]\n",
      "d\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "g = [1,2,3] \n",
    "print g\n",
    "print g[0] # Comme en C, les listes commencent par 0\n",
    "g[1]='deux'  # les listes sont modifiables (\"mutable\")\n",
    "print g\n",
    "print g[1][0] # accède au premier élément de l'élément 2 de la liste\n",
    "print g[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La liste est *mutable*, il est possible de lui ajouter des éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'deux', 3, 4]\n",
      "[1, 'deux', 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "g.append(4)\n",
    "print g\n",
    "g.extend([5,6,7])\n",
    "print g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention** les variables en Python sont des pointeurs, c'est à dire une adresse qui pointe vers un objet dans la mémoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'deux', 3, 4, 5, 6, 7]\n",
      "['un', 'deux', 3, 4, 5, 6, 7]\n",
      "['un', 'deux', 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "print g \n",
    "g2 = g\n",
    "g2[0] = 'un'\n",
    "print g2\n",
    "print g # La modification de la liste g2 entraine la modification de la liste g ... g et g2 pointent toutes les deux vers la même variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour être sûr de créer un nouvel objet, il faut utiliser le module copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['un', 'deux', 3, 4, 5, 6, 7]\n",
      "['un', 'deux', 3, 4, 5, 6, 'sept']\n",
      "['un', 'deux', 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "from copy import copy \n",
    "\n",
    "g2 = copy(g)\n",
    "\n",
    "print g\n",
    "g2[-1] = 'sept'\n",
    "print g2\n",
    "print g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La liste n'est qu'un container, elle ne réalise peu ou pas d'opérations numériques.\n",
    "\n",
    "La liste n'est pas l'équivalent du vecteur (on verra plus tard le vecteur dans numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['un', 'deux', 3, 4, 5, 6, 7, 'un', 'deux', 3, 4, 5, 6, 7]\n",
      "['un', 'deux', 3, 4, 5, 6, 7, 'un', 'deux', 3, 4, 5, 6, 7, 'un', 'deux', 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "print g+g\n",
    "print g*3\n",
    "# La liste se comporte comme la chaine de caractère. + est une opération de concaténation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe des fonctions de création de liste comme *range*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "h = range(1,4)\n",
    "print h "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les listes possèdent également des méthodes de tri et de recherche d'éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 0]\n",
      "[0, 1, 2, 3]\n",
      "[3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "h.append(0)\n",
    "print h \n",
    "\n",
    "h.sort()\n",
    "print h \n",
    "\n",
    "h.reverse()\n",
    "print h \n",
    "# Exercice : fabriquer une liste d'entier allant de 42 à 99 par pas de 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listes en compréhension \n",
    "(*comprehensive list*)\n",
    "\n",
    "Il s'agit d'une syntaxe spécifique pour créer des listes : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "cl = [ i**2 for i in range(5) ]\n",
    "print cl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les tuples \n",
    "\n",
    "Les tuples sont des listes *immutables*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Les tuples\n",
    "g = (1,2,3) # on utilise des parenthèses à la place des crochets pour la création\n",
    "print g \n",
    "print g[0]        # mais on indice des la même manière"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-244-0f8cdda09c6b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'test'\u001b[0m  \u001b[1;31m# les tuples ne sont pas modifiables (\"immutable\")\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "g[1]='test'  # les tuples ne sont pas modifiables (\"immutable\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 1, 2, 3)\n",
      "(1, 2, 3, 1, 2, 3, 1, 2, 3)\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print g+g\n",
    "print g*3\n",
    "print g == [1,2,3]\n",
    "print g == (1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'sort'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-247-ba39f7e6986f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'sort'"
     ]
    }
   ],
   "source": [
    "g.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les dictionnaires : \n",
    "Les dictionnaires sont des containers qui relient une clef à une valeur.\n",
    "Les dictionnaires reposent sur des tables de hachage et ont une complexité en temps de l'ordre de $\\mathcal{O}(1)$, c'est à dire que quelle que soit la taille d'un dictionnaire, le temps pour retrouver un élément est constant.\n",
    "\n",
    "Cette performance vient avec une limitation : les clefs d'un dictionnaire sont nécessairement *immutables* (pour être précis, elles doivent être *hashable*). On ne peut donc pas utiliser de listes comme clef. On peut cependant utiliser un tuple.\n",
    "Il n'y a pas de limitation sur les valeurs. Tout les objets peuvent être stockés dans un dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': [0, 1, 2, 'trois', ['toto']], 'text': 'zen', (0, 1): 'tuple'}\n"
     ]
    }
   ],
   "source": [
    "k = {} # dictionnaire vide\n",
    "k['A'] = [0,1,2,'trois',['toto']]\n",
    "k[\"text\"] = 'zen'\n",
    "k[(0,1)] = 'tuple' \n",
    "print k "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-250-c7e573206a44>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mk\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'list'\u001b[0m \u001b[1;31m# renvoie une erreur\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "k[[0,1]] = 'list' # renvoie une erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 'trois', ['toto']]\n"
     ]
    }
   ],
   "source": [
    "print k['A']  # retrouve la valeur associée à la clef 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'text', (0, 1)]"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k.keys() # retourne la liste des clefs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2, 'trois', ['toto']], 'zen', 'tuple']"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k.values() # retourne la liste des valeurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', [0, 1, 2, 'trois', ['toto']]), ('text', 'zen'), ((0, 1), 'tuple')]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k.items() #retourne la liste des paires clefs values sous la forme d'une liste de tuples "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut créer un dictionnaire directement : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'A', 2: 'B', 3: 'C'}\n"
     ]
    }
   ],
   "source": [
    "k2 = {1:'A',\n",
    "      2:'B',\n",
    "      3:'C'}\n",
    "print k2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou bien à partir d'une liste de (clefs, valeurs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'P': 'Puissance', 'T': 'Temp\\xc3\\xa9rature', 'H': 'humidit\\xc3\\xa9'}\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "k3 = dict( [('T','Température'),\n",
    "            ('P','Puissance'),\n",
    "            ('H','humidité')])\n",
    "print k3\n",
    "\n",
    "print 'T' in k3 # T est une clefs de k3\n",
    "print 't' in k3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** \n",
    "\n",
    "* En utilisant la fonction enumerate, créez un dictionnaire qui associe à chaque chiffre de 0 à 25 la lettre de l'alphabet correspondante\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefghijklmnopqrstuvwxyz\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "print string.ascii_lowercase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** \n",
    "\n",
    "* Décryptez le texte stocké dans le fichier zen.txt à l'aide du dictionnaire *d*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'N', 'C': 'P', 'B': 'O', 'E': 'R', 'D': 'Q', 'G': 'T', 'F': 'S', 'I': 'V', 'H': 'U', 'K': 'X', 'J': 'W', 'M': 'Z', 'L': 'Y', 'O': 'B', 'N': 'A', 'Q': 'D', 'P': 'C', 'S': 'F', 'R': 'E', 'U': 'H', 'T': 'G', 'W': 'J', 'V': 'I', 'Y': 'L', 'X': 'K', 'Z': 'M', 'a': 'n', 'c': 'p', 'b': 'o', 'e': 'r', 'd': 'q', 'g': 't', 'f': 's', 'i': 'v', 'h': 'u', 'k': 'x', 'j': 'w', 'm': 'z', 'l': 'y', 'o': 'b', 'n': 'a', 'q': 'd', 'p': 'c', 's': 'f', 'r': 'e', 'u': 'h', 't': 'g', 'w': 'j', 'v': 'i', 'y': 'l', 'x': 'k', 'z': 'm'}\n"
     ]
    }
   ],
   "source": [
    "from this import d\n",
    "print d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les dictionnaires en compréhension\n",
    "(*comprehensive dictionnary*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
     ]
    }
   ],
   "source": [
    "k4 = {k: k**2 for k in range(10)}\n",
    "print k4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Header|Header|Header|Header\n",
    "-|-|-|-\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Les variables et les objets\n",
    "* Une variable Python est un pointeur, c'est à dire une adresse vers un objet dans la mémoire vive de votre OS.\n",
    "* En Python, tout est objet (une liste est un objet, un module est un objet, une classe est un objet...).\n",
    "* Une variable peut être de plusieurs types : modifiable (*mutable*) ou non modifiable (*immutable*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "2 1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "print a\n",
    "print b\n",
    "a,b = b,a # permutation de variables\n",
    "print a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+b "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un objet Python possède : \n",
    "\n",
    "* des attributs : càd des informations qui le définissent\n",
    "* des méthodes : càd des fonctions permettant de le manipuler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"int(x=0) -> int or long\\nint(x, base=10) -> int or long\\n\\nConvert a number or string to an integer, or return 0 if no arguments\\nare given.  If x is floating point, the conversion truncates towards zero.\\nIf x is outside the integer range, the function returns a long instead.\\n\\nIf x is not a number or if base is given, then x must be a string or\\nUnicode object representing an integer literal in the given base.  The\\nliteral can be preceded by '+' or '-' and be surrounded by whitespace.\\nThe base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to\\ninterpret the base from the string as an integer literal.\\n>>> int('0b100', base=0)\\n4\""
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.__doc__ # La documentation d'un objet est disponible dans son attribut __doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<method-wrapper '__add__' of int object at 0x0000000001DE7970>\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print a.__add__ # la méthode __add__ permet d'additionner des variables entre elles. \n",
    "print a.__add__(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les méthodes  et les attributs commençant et finissant par \"\\_\\_\" sont des méthodes spéciales. \n",
    "\n",
    "Par exemple, Python interprete toujours la méthode \\_\\_add\\_\\_ comme la méthode permettant d'additioner un objet avec un autre.\n",
    "La méthode \\_\\_doc\\_\\_ est appelée sur un objet lorsque que l'on invoque la commande help(objet)\n",
    "\n",
    "Pour acceder à la liste des méthodes et des attributs d'un objet, vous pouvez taper dir(objet). En mode interactif dans Ipython, il suffit de taper un point à la suite du nom d'un objet et de faire tab.\n",
    "<img src=\"tab.png\"/> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les importations de packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python est modulaire, il repose sur un écosystème de packages permettant d'enrichir ses fonctionnalités (ie : toolbox matlab gratuite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemple : Le package datetime permet la manipulation des dates et du temps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015-03-04 08:30:00 2015-03-04 18:30:00\n",
      "10:00:00\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "start = datetime.datetime(2015,3,4,8,30)\n",
    "end = datetime.datetime(2015,3,4,18,30)\n",
    "t = end-start\n",
    "print start, end\n",
    "print t  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Wednesday March 2015 08::03::00\n",
      "36000\n"
     ]
    }
   ],
   "source": [
    "print start.isoweekday()\n",
    "print start.strftime('%A %B %Y %H::%m::%S')\n",
    "print t.seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour alléger les notations, il est possible de faire de imports relatifs : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015-03-03 10:38:53.282000\n",
      "2015-03-03 12:46:11.282000\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "\n",
    "dt = timedelta(hours=2,minutes=7,seconds=18)\n",
    "print datetime.utcnow()\n",
    "print datetime.utcnow()+dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :**\n",
    "\n",
    "* En utilisant les sous-modules datetime et timedelta, calculer le nombre de secondes entre le 1er juin 2012 et le début de cette formation.\n",
    "* Combien de jours cela fait-il? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les fonctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "funfunfunfunfun\n",
      "60\n",
      "60\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def fun2(a,b): \n",
    "    \n",
    "    return a*b\n",
    "\n",
    "print fun2('fun',5) \n",
    "print fun2(12,5)      # appel de fonction avec argument positionnel\n",
    "print fun2(b=5,a=12)  # appel de fonction avec argument par mot clef\n",
    "print a                # la valeur de la variable a n'a pas changé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print a\n",
    "\n",
    "def fun1():\n",
    "    print a\n",
    "    pass\n",
    "print fun1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    ">Notez que a n'était pas passé en argument... \n",
    " Les variables à l'extérieur des fonctions sont accessible dans la fonction... mais pas l'inverse\n",
    " fun1 ne reroune aucune valeur, son résultat est \n",
    " ```Python\n",
    "None\n",
    " ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def fun3(a=0):\n",
    "    return a\n",
    "\n",
    "print fun3() # Argument par défault\n",
    "print fun3(4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14 1\n",
      "(3.14, 1)\n",
      "(3.14, 1)\n",
      "Help on function fun4 in module __main__:\n",
      "\n",
      "fun4(param0, param1=1, param2=3.14)\n",
      "    Documentation ici\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def fun4(param0, param1 = 1, param2 = 3.14 ): \n",
    "    \"\"\"\n",
    "    Documentation ici\n",
    "    \n",
    "    \"\"\"\n",
    "    return param0*param1*param2, param0*param1\n",
    "\n",
    "res1,res2 = fun4(1)\n",
    "print res1, res2\n",
    "print fun4(param0 = 1)\n",
    "print fun4(param0=1, param1 = 1, param2 = 3.14 )\n",
    "# Toutes les lignes sont strictement équivalentes\n",
    "help(fun4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi définir des fonctions avec une liste d'arguments variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "1\n",
      "2\n",
      "3\n",
      "{'toto': 7, 'tata': 8}\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def fun5(req0,req1,opt0=0.0, opt1='c',opt2={},**kwargs):\n",
    "    print req0\n",
    "    print req1\n",
    "    print opt0\n",
    "    print opt1\n",
    "    print opt2   \n",
    "    print kwargs # key worded arguments\n",
    "    \n",
    "    return None\n",
    " \n",
    "print fun5(req0='a',req1='b',opt0=1,opt1=2,opt2=3,**{'toto':7,'tata':8})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Documentation de fonction avec le docstring (les triples quotes au début de la définition de la fonction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le module est executé en tant que script\n"
     ]
    }
   ],
   "source": [
    "def empty_documented_function(required_int,optional_float=0.0, optional_string='CSTB', *kargs ,**kwargs):\n",
    "    u\"\"\"\n",
    "Mettre ici la description de ce que la fonction fait.\n",
    "\n",
    "Des équations en ligne ici  :math:`T_{ext}(t)\\\\geq0^{\\\\circ}C`\n",
    "\n",
    "Des équations centrées ici : \n",
    "\n",
    ".. math:: e_{sat}(t) = 610.5e^{\\\\frac{17.269.T_{ext}(t)}{273.3+T_{ext}(t)}}   \n",
    "   \n",
    "Parameters\n",
    "----------\n",
    "required_int: int\n",
    "    required_int how great is the CSTB [1]_\n",
    "optional_float : float\n",
    "    optional_float is an optional float. Default value is 0.0.\n",
    "optional_string : string\n",
    "    optional_string is an optional string of character. Its default value is \n",
    "*kargs : a list \n",
    "    Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
    "    ``m * n * k`` samples are drawn.\n",
    "\n",
    "See Also\n",
    "--------\n",
    "myModule.myOtherFunctionDoingSimilarThing : also great.\n",
    "\n",
    "\n",
    "\n",
    "References\n",
    "----------\n",
    ".. [1] CSTB, \"Web site\",\n",
    "       http://www.cstb.fr/\n",
    "\n",
    "Examples\n",
    "--------\n",
    "\n",
    ">>> s = empty_function(2)\n",
    "\n",
    ">>> len(s)\n",
    "\n",
    "\n",
    "    \"\"\"\n",
    "    s = ' '.join(['CSTB is']+['great']*required_int+['!'])\n",
    "    \n",
    "    print s\n",
    "    return s\n",
    "\n",
    "if __name__ == \"__main__\" : \n",
    "    print(u'Le module est executé en tant que script')\n",
    "\n",
    "else : \n",
    "    print(u'Le module est importé')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "regarder l'aide de empty_documented_function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"data_type.png\"> </img>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mise en page des équations : \n",
    "http://martinkeefe.com/math/mathjax1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages par thèmes : \n",
    "\n",
    "* Matrice, algère linéaire, optimization, traitement du signal : \n",
    "    * numpy http://wiki.scipy.org/NumPy_for_Matlab_Users\n",
    "    * scipy https://docs.scipy.org/doc/scipy-0.14.0/reference/tutorial/index.html\n",
    "\n",
    "* Séries temporelles, données tabulaires :  Pandas http://pandas.pydata.org/pandas-docs/dev/tutorials.html\n",
    "\n",
    "* Statistiques : statsmodels http://statsmodels.sourceforge.net/\n",
    "\n",
    "* Apprentissage machine : scikitlearn http://scikit-learn.org/stable/\n",
    "\n",
    "* Processeur solaire : Pysolar https://github.com/pingswept/pysolar/tree/0.6\n",
    "\n",
    "* Graphes : \n",
    "    * matplotlib http://matplotlib.org/gallery.html\n",
    "    * seaborn http://stanford.edu/~mwaskom/software/seaborn/examples/index.html\n",
    "    * bokeh http://bokeh.pydata.org/en/latest/tutorial/\n",
    "    * plotly (online) https://plot.ly/python/\n",
    "\n",
    "* Cartographie : \n",
    "    * basemap http://matplotlib.org/basemap/\n",
    "    * folium http://bl.ocks.org/wrobstory/5609856\n",
    "    \n",
    "* Analyse de sensibilité et propagation d'incertitude : OpenTurns (outils EDF) http://www.openturns.org/\n",
    "\n",
    "* Inversion Bayesienne : Pymc http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Chapter1.ipynb\n",
    "\n",
    "* Calcul symbolique : Sympy http://docs.sympy.org/latest/tutorial/intro.html\n",
    "\n",
    "* Automatisation du travail sous EnergyPlus  : EPPY, http://www.datadrivenbuilding.org/\n",
    "\n",
    "* Lecture / écriture de fichier xml : lxml  http://lxml.de/tutorial.html\n",
    "\n",
    "* Requête http : requests http://docs.python-requests.org/en/latest/user/quickstart/\n",
    "\n",
    "* Traitement de document html : beautifulSoup http://www.crummy.com/software/BeautifulSoup/bs4/doc/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "console.log(\"Hello World!\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "console.log(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--bibtex\n",
    "\n",
    "@book{wellfarecut,\n",
    "    title = {Our Greatest Threat: The Rise of Anti-Wellfare Politics in Calico in the 21st Century},\n",
    "    author = {Jacob, Bernadette},\n",
    "    year = {2010},\n",
    "    publisher = {Jupyter University Press}\n",
    "}\n",
    "                  \n",
    "@article{militaryex2,\n",
    "    title = {Rethinking Calican Military Expansion for the New Century},\n",
    "    author = {Collier, Brian F.},\n",
    "    journal = {Modern Politics},\n",
    "    volume = {60},\n",
    "    issue = {25},\n",
    "    pages = {35 - 70},\n",
    "    year = {2012} \n",
    "}\n",
    "\n",
    "@article{militaryex1,\n",
    "    title = {Conservative Majority Passes Budget to Grow Military},\n",
    "    author = {Lane, Lois},\n",
    "    journal = {The Daily Calican},\n",
    "    month = {October 19th, 2011},\n",
    "    pages = {15 - 17},\n",
    "    year = {2011}\n",
    "}\n",
    "\n",
    "@article{oildrill,\n",
    "    title = {Oil Drilling Off the Coast of Jupyter Approved for Early Next Year},\n",
    "    author = {Marks, Meghan L.},\n",
    "    journal = {The Python Gazette},\n",
    "    month = {December 5th, 2012},\n",
    "    pages = {8 - 9},\n",
    "    year = {2012}\n",
    "}\n",
    "\n",
    "@article{rieseinterview,\n",
    "    title = {Interview with Up and Coming Freshman Senator, Alec Riese of Python},\n",
    "    author = {Wilmington, Oliver},\n",
    "    journal = {The Jupyter Times},\n",
    "    month = {November 24th, 2012},\n",
    "    pages = {4 - 7},\n",
    "    year = {2012}\n",
    "}\n",
    "\n",
    "@book{calicoww2:1,\n",
    "    title = {Calico and WWII: Untold History},\n",
    "    author = {French, Viola},\n",
    "    year = {1997},\n",
    "    publisher = {Calicia City Free Press}\n",
    "}\n",
    "\n",
    "@book{calicoww2:2,\n",
    "    title = {Rebuilding Calico After Japanese Occupation},\n",
    "    author = {Kepps, Milo },\n",
    "    year = {2002},\n",
    "    publisher = {Python Books}\n",
    "}\n",
    "-->"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}