General/Prise_en_main_de_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Touches essentielles du notebook\n",
    "- CTRL-ENTER pour exécuter une cellule et rester dedans.\n",
    "- ALT-ENTER pour exécuter une cellule en créer une autre en dessous et passer dedans.\n",
    "- MAJ-ENTER pour exécuter une cellule et passer dans celle de dessous."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Principes Généraux de Python\n",
    "- Indentation\n",
    "- typage : duck typing, garbage collection, références, collection\n",
    "- modèle de programmation : POO/fonctionnel/structuré\n",
    "- architecture : builtin/librairie standard/librairie annexe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types\n",
    "- int\n",
    "- float\n",
    "- tuple\n",
    "- listes\n",
    "- chaines de caractères\n",
    "- dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type de donnée : <class 'int'> chaine supplémenaire\n",
      "addition : 5\n",
      "soustraction : 1\n",
      "multiplication : 6\n",
      "puissance : 9\n",
      "division euclidienne : 1\n",
      "reste : 1\n",
      "division : 1.5\n"
     ]
    }
   ],
   "source": [
    "a=3\n",
    "b=2\n",
    "print(\"type de donnée :\", type(a), \"chaine supplémenaire\")\n",
    "print(\"addition :\",a+b)\n",
    "print(\"soustraction :\", a-b)\n",
    "print(\"multiplication :\", a*b)\n",
    "print(\"puissance :\", a**b)\n",
    "print(\"division euclidienne :\",a//b)\n",
    "print(\"reste :\", a%b)\n",
    "print(\"division :\", a/b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nombres flottants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type de donnée : <class 'float'>\n",
      "addition : 6.3\n",
      "soustraction : 0.7000000000000002\n",
      "multiplication : 9.799999999999999\n",
      "puissance : 33.37263696900644\n",
      "division euclidienne : 1.0\n",
      "reste : 0.7000000000000002\n",
      "division : 1.25\n"
     ]
    }
   ],
   "source": [
    "a=3.5\n",
    "b=2.8\n",
    "print(\"type de donnée :\", type(a))\n",
    "print(\"addition :\",a+b)\n",
    "print(\"soustraction :\", a-b)\n",
    "print(\"multiplication :\", a*b)\n",
    "print(\"puissance :\", a**b)\n",
    "print(\"division euclidienne :\",a//b)\n",
    "print(\"reste :\", a%b)\n",
    "print(\"division :\", a/b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pour la conversion.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type : <class 'float'> valeur : 1.5\n",
      "type : <class 'int'> valeur : 1\n",
      "type : <class 'float'> valeur : 1.0\n"
     ]
    }
   ],
   "source": [
    "a=1.5\n",
    "print(\"type :\", type(a), \"valeur :\", a)\n",
    "b=int(a)\n",
    "print(\"type :\", type(b), \"valeur :\", b)\n",
    "c=float(b)\n",
    "print(\"type :\", type(c), \"valeur :\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type de donnée :\n",
      "<class 'tuple'> valeur : (1, 2)\n"
     ]
    }
   ],
   "source": [
    "x=(1,2)\n",
    "print(\"type de donnée :\")\n",
    "print(type(x), \"valeur :\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Accès au différents éléments.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "premier élément : 1\n",
      "deuxième élément : 2\n"
     ]
    }
   ],
   "source": [
    "print(\"premier élément :\", x[0])\n",
    "print(\"deuxième élément :\", x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "y=(1,2,3,4,5,4,3,2,1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "premier indexe où on à la valeur 5 : 4\n",
      "combien de fois a-t-on 4 : 2\n"
     ]
    }
   ],
   "source": [
    "print(\"premier indexe où on à la valeur 5 :\", y.index(5))\n",
    "print(\"combien de fois a-t-on 4 :\", y.count(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-336e692b378d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0my\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\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": [
    "y[0]=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type de donnée : <class 'list'>\n",
      "valeur : [1, 2, 3, 4, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "liste=[1,2,3,4,5,4,3,2,1]\n",
    "print(\"type de donnée :\", type(liste))\n",
    "print(\"valeur :\", liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comme pour les tuple :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "première valeur 1\n",
      "dernière valeur : 1\n",
      "découpage : [2, 3, 4]\n",
      "découpage plus fin : [2, 4, 4, 2]\n",
      "premier indexe où on à la valeur 5 : 4\n",
      "combien de fois a-t-on 4 : 2\n"
     ]
    }
   ],
   "source": [
    "print(\"première valeur\", liste[0])\n",
    "print(\"dernière valeur :\", liste[-1])\n",
    "print(\"découpage :\", liste[1:4])\n",
    "print(\"découpage plus fin :\", liste[1::2])\n",
    "print(\"premier indexe où on à la valeur 5 :\", liste.index(5))\n",
    "print(\"combien de fois a-t-on 4 :\", liste.count(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Différence : structure dynamique.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [1, 2, 3, 4, 5, 4, 3, 2, 1]\n",
      "après : [1, 2, 3, 4, 5, 4, 3, 2, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.append(2)\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [1, 2, 3, 4, 5, 4, 3, 2, 1, 2]\n",
      "après [1, 2, 3, 4, 5, 4, 3, 2, 1]\n",
      "et on a récupéré la valeur manquante : 2\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "c=liste.pop()\n",
    "print(\"après\", liste)\n",
    "print(\"et on a récupéré la valeur manquante :\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**De nombreuses méthodes disponibles.**  \n",
    "Utiliser la touche `TAB` après avoir tapé :    \n",
    "```\n",
    "liste.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [1, 2, 3, 4, 5, 4, 3, 2, 1]\n",
      "après : [1, 1, 2, 2, 3, 3, 4, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.sort()\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [1, 1, 2, 2, 3, 3, 4, 4, 5]\n",
      "après : [5, 4, 4, 3, 3, 2, 2, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.reverse()\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [5, 4, 4, 3, 3, 2, 2, 1, 1]\n",
      "après : [5, 4, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.extend([1.5, 1.6, 1.7, 1.8])\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [5, 4, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8]\n",
      "après : [5, 4, -5, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.insert(2,-5)\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avant : [5, 4, -5, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8]\n",
      "après : [5, 4, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8]\n"
     ]
    }
   ],
   "source": [
    "print(\"avant :\", liste)\n",
    "liste.remove(-5)\n",
    "print(\"après :\", liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 4, -5, 4, 3, 3, 2, 2, 1, 1, 1.5, 1.6, 1.7, 1.8)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**On verra des techniques de construction plus élaborées au moment de la discussion des boucles.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chaines de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type de valeur : <class 'str'>\n",
      "valeur : Journée CASCIMODOT\n"
     ]
    }
   ],
   "source": [
    "chaine=\"Journée CASCIMODOT\"\n",
    "print(\"type de valeur :\", type(chaine))\n",
    "print(\"valeur :\", chaine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comme pour les tuples et les listes.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "découpage : oré ACMDT\n",
      "première occurence du c majuscule : 8\n",
      "nombres d'occurences de la lettre O : 2\n"
     ]
    }
   ],
   "source": [
    "print(\"découpage :\", chaine[1::2])\n",
    "print(\"première occurence du c majuscule :\", chaine.index('C'))\n",
    "print(\"nombres d'occurences de la lettre O :\", chaine.count('O'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Utilisation d'autres déclarations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chaineBis = 'Journée CASCIMODOT'\n",
    "chaineTierce = \"\"\"Pour inclure plusieurs lignes\n",
    "cette syntaxe est particulièrement pratique\n",
    "comme on peut le constater\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pour inclure plusieurs lignes\n",
      "cette syntaxe est particulièrement pratique\n",
      "comme on peut le constater\n"
     ]
    }
   ],
   "source": [
    "print(chaineTierce)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Et pour obtenir de l'aide taper :**\n",
    "```\n",
    "chaineTierce.split?\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ENORMEMENT de méthodes disponible.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Journée CASCIMODOT\n",
      "mise en majuscule : Journée cascimodot\n",
      "remplissage avec des caractères : ****************Journée CASCIMODOT****************\n",
      "recherche de sous-chaine 4\n",
      "échange : jOURNÉE cascimodot\n",
      "séparation autour d'un caractère (défaut espace) ['Journée', 'CASCIMODOT']\n"
     ]
    }
   ],
   "source": [
    "print(chaine)\n",
    "print(\"mise en majuscule :\", chaine.capitalize())\n",
    "print(\"remplissage avec des caractères :\", chaine.center(50,'*'))\n",
    "print(\"recherche de sous-chaine\", chaine.find('née'))\n",
    "print(\"échange :\", chaine.swapcase())\n",
    "print(\"séparation autour d'un caractère (défaut espace)\", chaine.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Possibilité d'inclure des variables.**  \n",
    "*syntaxe beaucoup plus riche que ce qui est montré ci dessous*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le prochaine 2.0000008 paragraphe 2.0000008 est le numéro 2.0\n"
     ]
    }
   ],
   "source": [
    "a=2.0000008\n",
    "b=1.2\n",
    "c=1.3\n",
    "message='Le prochaine {0} paragraphe {0} est le numéro {0:.2}'.format(a,b,c)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conversions possibles.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type : <class 'int'>\n",
      "valeur : 11\n",
      "type : <class 'str'>\n",
      "valeur : 11\n"
     ]
    }
   ],
   "source": [
    "a=int('11')\n",
    "print(\"type :\", type(a))\n",
    "print(\"valeur :\", a)\n",
    "b=str(11)\n",
    "print(\"type :\", type(b))\n",
    "print(\"valeur :\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la liste est : ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
      "On peut la réunir : abcdefghijklmnopqrstuvwxyz\n",
      "En choisissant les séparateurs a* *b* *c* *d* *e* *f* *g* *h* *i* *j* *k* *l* *m* *n* *o* *p* *q* *r* *s* *t* *u* *v* *w* *x* *y* *z\n"
     ]
    }
   ],
   "source": [
    "chaine='abcdefghijklmnopqrstuvwxyz'\n",
    "liste=list(chaine)\n",
    "print(\"la liste est :\", liste)\n",
    "print('On peut la réunir :', \"\".join(liste))\n",
    "print(\"En choisissant les séparateurs\", \"* *\".join(liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Les listes stockent tout type de donnée.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], 'a', 0.2, 0.2, 12, ['chaine']]\n"
     ]
    }
   ],
   "source": [
    "liste=[[1,2,3], 'a', 1/5, 0.2, 12, \"chaine\".split()]\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionnaires\n",
    "Permettent d'indexer autrement que par des entiers. Permettent de coder une correspondance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type : <class 'dict'>\n",
      "valeur : {'c': 5, 2: 3, 'b': 1, 'd': 7, 'a': 2}\n"
     ]
    }
   ],
   "source": [
    "dico={'a':2, 'b':1, 'c':5, 'd':7, 2: 3}\n",
    "print('type :', type(dico))\n",
    "print(\"valeur :\", dico)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(dico['a'])\n",
    "print(dico[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 2, 3: 4, 5: 6}\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "dico = dict(((1,2),(3,4),(5,6)))\n",
    "print(dico)\n",
    "print(dico[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nombreuses méthodes (taper dico. puis la touche de tabulation puis pour l'aide ajouter point d'interrogation).**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables et affectations\n",
    "références, affectation et unpacking+permutation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Unpacking.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plusieurs variables affectées en mêmes temps\n",
      "a : 1\n",
      "b : 2\n",
      "c : 3\n"
     ]
    }
   ],
   "source": [
    "a,b,c=1,2,3\n",
    "print('plusieurs variables affectées en mêmes temps')\n",
    "print('a :', a)\n",
    "print('b :', b)\n",
    "print('c :', c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : 1\n",
      "b : 2\n",
      "c : 3\n",
      "d : 4\n"
     ]
    }
   ],
   "source": [
    "liste=[1,2,3,4]\n",
    "a,b,c,d = liste\n",
    "print('a :', a)\n",
    "print('b :', b)\n",
    "print('c :', c)\n",
    "print('d :', d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : a\n",
      "b : [1, 2, 'b']\n",
      "c : essai\n"
     ]
    }
   ],
   "source": [
    "liste=('a',1,2,'b','essai')\n",
    "a, *b, c=liste\n",
    "print('a :', a)\n",
    "print('b :', b)\n",
    "print('c :', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Mutation et références.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "2 1\n"
     ]
    }
   ],
   "source": [
    "a=1\n",
    "b=a\n",
    "print(a,b)\n",
    "a=2\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3] [1, 2, 3]\n",
      "[4, 5, 6] [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3]\n",
    "b=a\n",
    "print(a,b)\n",
    "a=[4,5,6]\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3] [1, 2, 3]\n",
      "[1, 2, 3, 4] [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3]\n",
    "b=a\n",
    "print(a,b)\n",
    "a.append(4)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4] [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a=a[1:4]\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "c=a.append(4)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**MORALITE : Pas de copie par défaut.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fonctions\n",
    "valeur par défaut arguments positionnels, arguments par mots clés, `pass`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntaxe élémentaire.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def maFonction(x):\n",
    "    y=2*x\n",
    "    return y\n",
    "print(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maFonction(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maFonction(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 2, 3)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maFonction((2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maFonction([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blablablabla'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maFonction(\"blabla\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Arguments par défaut.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def puissance(n, p=2):\n",
    "    return n**p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puissance(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puissance(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puissance(n=4, p=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puissance(p=3, n=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Docstring**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def documentation():\n",
    "    \"\"\"Ceci est retournée par l'aide lorsqu'on la demande.\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "documentation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention lorsque l'agument par défaut est mutable.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def problematique(liste=[]):\n",
    "    liste.append(1)\n",
    "    return liste\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problematique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problematique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problematique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def problematiqueBis(liste=None):\n",
    "    if liste is None:\n",
    "        liste=list()\n",
    "    liste.append(1)\n",
    "    return liste\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problematiqueBis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problematiqueBis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test\n",
    "**booléens**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'> <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(True),type(False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'> True\n"
     ]
    }
   ],
   "source": [
    "a=1\n",
    "test = (a==1)\n",
    "print(type(test), test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "test2 = (a<=2.0)\n",
    "print(test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testBateau(a):\n",
    "    if a==1:\n",
    "        print(\"Ok\")\n",
    "    else:\n",
    "        print(\"pas Ok\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ok\n",
      "pas Ok\n"
     ]
    }
   ],
   "source": [
    "testBateau(1)\n",
    "testBateau(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testAvance(a):\n",
    "    if isinstance(a, type(\" \")):\n",
    "        print(\"Chaine de caractére\")\n",
    "    elif isinstance(a, type(1)):\n",
    "        print(\"Entier\")\n",
    "    elif isinstance(a, list):\n",
    "        print(\"Liste\")\n",
    "    else:\n",
    "        print(\"pas clair\")\n",
    "        \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entier\n"
     ]
    }
   ],
   "source": [
    "testAvance(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liste\n"
     ]
    }
   ],
   "source": [
    "testAvance([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucle `while`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def premier(n):\n",
    "    i=2\n",
    "    while i**2<n:\n",
    "        if n%i != 0:\n",
    "            i+=1\n",
    "        else:\n",
    "            print(\"Le nombre {} est composite\".format(n))\n",
    "    print(\"Le nombre {} est premier.\".format(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le nombre 13 est premier.\n"
     ]
    }
   ],
   "source": [
    "premier(13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le nombre 100 est composite\n"
     ]
    }
   ],
   "source": [
    "premier(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucle `for`\n",
    "itération généralisées, condition `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "1\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "liste = ['A', 1, [1,2,3]]\n",
    "for element in liste:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "a\n",
      "b\n",
      "bcd\n"
     ]
    }
   ],
   "source": [
    "uplet = (1,2,3,4,'a','b','bcd')\n",
    "for element in uplet:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Itération sur des objets plus \"compliqués\".**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c  :  3\n",
      "b  :  2\n",
      "a  :  1\n"
     ]
    }
   ],
   "source": [
    "dico = {'a':1, 'b':2, 'c':3}\n",
    "for indice in dico:\n",
    "    print(indice,\" : \", dico[indice])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c  :  3\n",
      "b  :  2\n",
      "a  :  1\n"
     ]
    }
   ],
   "source": [
    "for indice, valeur in dico.items():\n",
    "    print(indice, \" : \", valeur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for valeur in dico.values():\n",
    "    print(valeur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Et quand on aurait besoin d'un indice.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "indice 0 lettre b :\n",
      "indice 1 lettre l :\n",
      "indice 2 lettre a :\n",
      "indice 3 lettre b :\n",
      "indice 4 lettre l :\n",
      "indice 5 lettre a :\n",
      "indice 6 lettre b :\n",
      "indice 7 lettre l :\n",
      "indice 8 lettre a :\n",
      "indice 9 lettre b :\n",
      "indice 10 lettre l :\n",
      "indice 11 lettre a :\n",
      "indice 12 lettre b :\n",
      "indice 13 lettre l :\n",
      "indice 14 lettre a :\n"
     ]
    }
   ],
   "source": [
    "liste= list('blablablablabla')\n",
    "for i,lettre in enumerate(liste):\n",
    "    print(\"indice {0} lettre {1} :\".format(i, lettre))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Discuter avantages itérateurs.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compréhension de liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "liste=[i**2 for i in range(1,10)]\n",
    "for nombre in liste:\n",
    "    print(nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "16\n",
      "49\n",
      "100\n",
      "169\n",
      "256\n",
      "361\n"
     ]
    }
   ],
   "source": [
    "liste=[i**2 for i in range(1,20) if i%3==1]\n",
    "for nombre in liste:\n",
    "    print(nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pour les trop grosses listes.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def est_premier(nb):\n",
    "    for div in range(2,nb-1):\n",
    "        if nb%div == 0:\n",
    "            return False\n",
    "    return True\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "25\n",
      "49\n",
      "121\n",
      "169\n",
      "289\n",
      "361\n"
     ]
    }
   ],
   "source": [
    "for i in (i**2 for i in range(1,20) if est_premier(i)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fichiers\n",
    "syntaxe standard par `with`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(\"test.txt\", 'w') as aecrire:\n",
    "    aecrire.write(\"première ligne?\")\n",
    "    aecrire.write(\"deuxième ligne?\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "première ligne?deuxième ligne?\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\", 'r') as alire:\n",
    "    print(alire.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(\"test.txt\", 'a') as arajouter:\n",
    "    arajouter.write(\"\\nNouvelle ligne si tout va bien\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "première ligne?deuxième ligne?\n",
      "Nouvelle ligne si tout va bien\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\", 'r') as alire:\n",
    "    print(alire.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "première ligne?deuxième ligne?\n",
      "\n",
      "Nouvelle ligne si tout va bien\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\", 'r') as alire:\n",
    "    for ligne in alire:\n",
    "        print(ligne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Là encore un objet fichier à de multiples méthodes.**  \n",
    "Tester avec l'autocomplétion, ne pas oublier de fermer avec la méthode `close`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gestion des erreurs\n",
    "`try except`, `raise`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def division(num, den):\n",
    "    return num/den"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-95-78dd29d37371>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdivision\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-94-6e247ed36ea1>\u001b[0m in \u001b[0;36mdivision\u001b[1;34m(num, den)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdivision\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mden\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mnum\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mden\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "division(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def divisionCorrige(num, den):\n",
    "    try:\n",
    "        return num/den\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Diviser par zéro c'est mal!\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diviser par zéro c'est mal!\n"
     ]
    }
   ],
   "source": [
    "divisionCorrige(1,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**MORALE : Mieux vaut demander pardon que la permission (en temps de calcul en tout cas)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Builtin\n",
    "- fonctionnel : `map`, `lambda`, `filter`, `zip`\n",
    "- manipulation : `reversed`, `sorted`,  `slice`, `enumerate`, `format`\n",
    "- vectorisation : `sum`, `max`, `min`, `round`, `len`, \n",
    "- interaction basique utilisateur : `print`, `input`, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Librairies\n",
    "`import` ou `from import`\n",
    "Exemples `math`, `random`, `requests`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On pourra tester l'appui de la touche `TAB` après avoir tapé :  \n",
    "```\n",
    "math.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(2)+math.sin(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random as rd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9050920463816937\n",
      "0.5204006599682303\n",
      "0.34815214614001877\n",
      "0.30724764384941183\n",
      "0.16355652104826257\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(rd.random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "copy.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from copy import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4] [1, 2, 3, 4]\n",
      "[1, 2, 3, 4, 5] [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3,4]\n",
    "b=copy(a)\n",
    "print(a,b)\n",
    "a.append(5)\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lenteur relative\n",
    "Ordre usuel : \n",
    "1. Prototypage, \n",
    "2. Profilage (%%timeit, %%prun, line_profiler), \n",
    "3. Optimisation (`numpy`, `numba`, `pypy`, `cython`, `cffi`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorisation du code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def carree(M):\n",
    "    n=len(M)\n",
    "    resultat=list()\n",
    "    for i in range(n):\n",
    "        resultat.append(list())\n",
    "        for j in range(n):\n",
    "            S=0\n",
    "            for k in range(n):\n",
    "                S+=M[i][k]*M[k][j]\n",
    "            resultat[i].append(S)\n",
    "    return resultat\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[30, 36, 42], [66, 81, 96], [102, 126, 150]]\n"
     ]
    }
   ],
   "source": [
    "M=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "print(M)\n",
    "print(carree(M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=300\n",
    "M=[list(range(n)) for i in range(n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loops, best of 3: 6.55 s per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "carree(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def carreeBis(M):\n",
    "    return M*M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       "        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def creation(n):\n",
    "    return np.matrix(np.tile(np.arange(n),n).reshape((n,n)))\n",
    "\n",
    "creation(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M=creation(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 loops, best of 3: 8.61 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "carreeBis(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from numba import jit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit\n",
    "def carreeTierce(M):\n",
    "    n,m=M.shape\n",
    "    assert n==m\n",
    "    resultat=np.zeros((n,n))\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            S=0\n",
    "            for k in range(n):\n",
    "                S+=M[i,k]*M[k,j]\n",
    "            resultat[i,j]=S\n",
    "    return resultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M=creation(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 52.30 times longer than the fastest. This could mean that an intermediate result is being cached \n",
      "1 loops, best of 3: 10.2 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "carreeTierce(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecosystème\n",
    "======\n",
    "Quelle librairie utiliser? exemples. `urllib2/requests`, `matplotlib/bokeh`, `beautiful soup/lxml`..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non dits\n",
    "=====\n",
    "- syntaxe avancée : keywords et arguments positionnels, générateurs, itérateurs, décorateurs\n",
    "- parallélisme et le GIL\n",
    "- debugging\n",
    "- POO"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.1"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}