{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "canopy_exercise": {
     "cell_type": "question"
    }
   },
   "source": [
    "# L3 E - S5 2018-19--- TD ordinateurs --- séance 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les noms de $variables$ sont des noms que l'on choisit librement pour les objets que l'on va manipuler. Voici quelques exemples d'affectation de $variables$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=3\n",
    "b=3.0 \n",
    "xy=-5.7\n",
    "xz=234567889\n",
    "je_ne_suis_pas_une_variable=23\n",
    "x=2,5,7\n",
    "xx=\"2,5,7\"\n",
    "azerty=\"coucou\"\n",
    "poiuyt='true'\n",
    "ma_variable=True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour s'assurer que nos variables existent bien, demandons leur valeur ! :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3.0, -5.7, 234567889, 23, (2, 5, 7), '2,5,7', 'coucou', 'true', True)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,xy,xz,je_ne_suis_pas_une_variable,x,xx,azerty,poiuyt,ma_variable"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "On aurait pu créer ainsi un nouvel objet "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nouvel_objet = a,b,xy,xz,je_ne_suis_pas_une_variable,x,xx,azerty,poiuyt,ma_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3.0, -5.7, 234567889, 23, (2, 5, 7), '2,5,7', 'coucou', 'true', True)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nouvel_objet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'on veut faire apparaître les valeurs successives de nos variables, on voit que la commande suivante ne le permet pas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a\n",
    "b\n",
    "xy\n",
    "je_ne_suis_pas_une_variable\n",
    "azerty\n",
    "ma_variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seule la valeur de la dernière variable demandée apparaît. On peut par contre demander (et on note, au passage, la possibilité avec le caractère $\\#$ d'introduire des commentaires, c'est-à-dire, du texte qui n'est pas pris en compte dans l'exécution ; c'est très utile, voire indispensable quand un programme contient un nombre important de commandes) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3.0\n",
      "-5.7\n",
      "23\n",
      "coucou\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)\n",
    "print(xy)\n",
    "print(je_ne_suis_pas_une_variable)  # ici, j'écris un commentaire... \n",
    "                                    # et mon commentaire est aussi long que je \n",
    "           # veux, il peut même faire plusieurs lignes \n",
    "        #(à condition de ne pas oublier le symbole # au début\n",
    "print(azerty)\n",
    "print(ma_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi vouloir plus de clarté ou de précision :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 3\n",
      "b = 3.0\n",
      "-5.7\n",
      "je_ne_suis_pas_une_variable = 23\n",
      "coucou\n",
      "le texte ou commentaire que l'on veut True\n"
     ]
    }
   ],
   "source": [
    "print('a =',a)\n",
    "print(\"b =\",b)\n",
    "print(xy)\n",
    "print(\"je_ne_suis_pas_une_variable =\",je_ne_suis_pas_une_variable)\n",
    "print(azerty)\n",
    "print(\"le texte ou commentaire que l'on veut\",ma_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On remarque la différence d'affichage : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coucou\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'coucou'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(azerty)\n",
    "azerty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notons que tous les caractères ne sont pas permis dans les noms de variables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to operator (<ipython-input-18-e7ce133c7c9e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-18-e7ce133c7c9e>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    nouvel-objet=7\u001b[0m\n\u001b[0m                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to operator\n"
     ]
    }
   ],
   "source": [
    "nouvel-objet=7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certains noms sont réservés :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-19-00fdc22a1374>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-19-00fdc22a1374>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    if=28\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if=28"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python fait la différence entre minuscules et majuscules :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1416\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'Valeur' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-3f382a39e512>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mvaleur\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3.1416\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvaleur\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mValeur\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'Valeur' is not defined"
     ]
    }
   ],
   "source": [
    "valeur=3.1416\n",
    "print(valeur)\n",
    "print(Valeur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "et certains caractères (comme les accents) peuvent ne pas être bienvenus ; tout dépend de l'environnement, voici un test :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'élémentaire, mon cher Benoît !'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=\"élémentaire, mon cher Benoît !\"\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces quelques exemples montrent qu'il existe plusieurs sortes d'objets ; chaque objet a un type :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "élémentaire, mon cher Benoît ! <class 'str'>\n",
      "3.0 <class 'float'>\n",
      "-5.7 <class 'float'>\n",
      "234567889 <class 'int'>\n",
      "(2, 5, 7) <class 'tuple'>\n",
      "2,5,7 <class 'str'>\n",
      "coucou <class 'str'>\n",
      "23 <class 'int'>\n",
      "true <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(a,type(a))  # coome ça, ce sera plus clair\n",
    "print(b,type(b))\n",
    "print(xy,type(xy))\n",
    "print(xz,type(xz))   \n",
    "print(x,type(x))\n",
    "print(xx,type(xx))\n",
    "print(azerty,type(azerty))\n",
    "print(je_ne_suis_pas_une_variable,type(je_ne_suis_pas_une_variable))\n",
    "print(poiuyt,type(poiuyt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S'il ne connaît pas la variable, $\\texttt{Python}$ nous le dit : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'babar' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-796dcd02b853>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbabar\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbabar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'babar' is not defined"
     ]
    }
   ],
   "source": [
    "print(babar,type(babar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici donc déjà quatre sortes de types : \n",
    "\n",
    "- $\\texttt{int}$, $\\texttt{float}$ : type $numérique$\n",
    "\n",
    "- $\\texttt{tuple}$, $\\texttt{str}$ : type $\\texttt{sequence}$. Une séquence est une collection ordonnée ; on verra aussi le type $\\texttt{list}$ et on reviendra très rapidement sur les types $\\texttt{sequence}$, ils sont incontournables !!\n",
    "\n",
    "- $\\texttt{bool}$  : type $booléen$ ; les deux seules valeurs possibles sont $\\texttt{True}$ et $\\texttt{False}$\n",
    "\n",
    "Cette liste n'est pas exhaustive... Notons juste pour terminer cette introduction que, comme leur nom l'indique, le contenu d'une $variable$ peut changer (réaffectation) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "élémentaire, mon cher Benoît !\n",
      "-6\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a=18\n",
    "b=-6\n",
    "print(b)\n",
    "b=a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On n'oubliera pas que la notation des décimaux se fait avec le point :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4 <class 'float'>\n",
      "(3, 4) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "d=3.4\n",
    "dd=3,4\n",
    "print(d,type(d))\n",
    "print(dd,type(dd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, la bibliothèque $\\texttt{math}$ permet d'utiliser des décimaux célèbres ; exemples : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérations élémentaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pi= 256\n",
      "Pi= 1000\n",
      "est-il vrai que pi=256 ? True\n",
      "pi= 3.141592653589793\n",
      "Pi= 1000\n",
      "est-il vrai que pi=256 ? False\n",
      "e= 2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "pi = 256\n",
    "Pi=1000\n",
    "print(\"pi=\", pi)\n",
    "print(\"Pi=\", Pi)\n",
    "print(\"est-il vrai que pi=256 ?\", pi==256)\n",
    "from math import *\n",
    "print(\"pi=\", pi)\n",
    "print(\"Pi=\", Pi)\n",
    "print(\"est-il vrai que pi=256 ?\", pi==256)\n",
    "print(\"e=\",e)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce paragraphe, nous voyons comment Pythion exécute les opérations arithmétiques élémentaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b = 18\n",
      "ab= 65\n",
      "3a-4b= 19\n",
      "1024\n",
      "10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376\n",
      "144\n",
      "144\n"
     ]
    }
   ],
   "source": [
    "a=13\n",
    "b=5\n",
    "print('a+b =',a+b)\n",
    "print('ab=',a*b)\n",
    "print('3a-4b=',3*a-4*b)\n",
    "print(2**10)\n",
    "print(2**1000)\n",
    "print(a**2-b**2)\n",
    "print((a-b)*(a+b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention à la division !! :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 13.4 <class 'float'>\n",
      "b = 5 <class 'int'>\n",
      "c = 13 <class 'int'>\n",
      "2.68 <class 'float'>\n",
      "2.0 <class 'float'>\n",
      "2.6 <class 'float'>\n",
      "2 <class 'int'>\n",
      "0.0 <class 'float'>\n",
      "0.9701492537313433 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a=13.4\n",
    "b=5\n",
    "c=13\n",
    "print('a =',a,type(a))\n",
    "print(\"b =\",b,type(b))\n",
    "print('c =',c,type(c))\n",
    "print(a/b,type(a/b))\n",
    "print(a//b,type(a//b))\n",
    "print(c/b, type(c/b))\n",
    "print(c//b, type(c//b))\n",
    "print(c//a, type(c//a))\n",
    "print(c/a, type(c/a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(13.4, 5, 13, 13.0, 0.40000000000000036, 5.0, 3.4000000000000004, 3, 5)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c,c%a,a%c,b%a,a%b,c%b,b%c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour vérifier qu'on a compris ces différents opérateurs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = 2 * 10 + 5\n",
      "A = 2.0 * 8.4 + 8.2\n",
      "C = 0.0 * 10 + 8.4\n"
     ]
    }
   ],
   "source": [
    "A,B,C=25,10,8.4\n",
    "print('A =', A//B, '*',B,'+',A%B)\n",
    "print('A =', A//C, '*',C,'+',A%C)\n",
    "print('C =', C//B, '*',B,'+',C%B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou encore, en utilsant les booléens et les opérateurs de comparaisons  :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "est-ce que A=A1 ? False\n",
      "est-ce que A=A2 ? True\n"
     ]
    }
   ],
   "source": [
    "A1=A/B*B+A%B\n",
    "A2=A//B*B+A%B\n",
    "print(\"est-ce que A=A1 ?\",A==A1)\n",
    "print(\"est-ce que A=A2 ?\",A==A2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Profitons de l'occasion pour regarder d'autres opérateurs de comparaison :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(3>4)\n",
    "print(3!=4)\n",
    "print(3<4)\n",
    "print(3<=4)\n",
    "print((3+1)>4)\n",
    "print((3+1)>=4)\n",
    "print(3==4)\n",
    "print((3*5)==(4+11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour terminer ce paragraphe, notons la différence :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 * 10 + 5\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "print(A//B, '*',B,'+',A%B)\n",
    "print(A//B*B+A%B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous rentrez l'heure h, la minute m et la seconde s actuelles, vous obtenez ainsi directement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "h,m,s=8,28,17\n",
    "print(\"Il s'est écoulé\", 3600*h+60*m+s,\"secondes depuis minuit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 1 - Conversion de secondes\n",
    "\n",
    "a) Ecrire un programme qui convertit en années, mois, jours, heures, minutes et secondes une durée de 123456789 secondes et afficher le résultat sous la forme 123456789 secondes = $a$ années $j$ jours $h$ heures $m$ minutes $s$ secondes\n",
    "\n",
    "b) Ecrire un programme qui convertit en millénaires, siècles, années, mois, jours, heures, minutes et secondes une durée de 123456789987654321 secondes et afficher le résultat sous la forme 123456789987654321 secondes = $M$ millénaires $S$ siècles $a$ années $j$ jours $h$ heures $m$ minutes $s$ secondes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2 - Conversion de degrés en radians\n",
    "\n",
    "Ecrire un programme qui convertit en radians un angle $A$ de 155 degrés 8 minutes et 13 secondes en affichant le résultat sous la forme : un angle de 155 ° 8 ' 13 \" vaut $x$ radians"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Un mot sur les chaînes (string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il s'agit du type str (pour string) que l'on a déjà rencontré. Il fait partie de la famille des $\\texttt{sequences}$ (i.e., des $suites$) comme les $\\texttt{tuples}$ (déjà rencontrés) ou les $\\texttt{listes}$ (qui feront l'objet du paragraphe suivant). Une $chaîne$ est délimitée par des $guillemets$ (\" ... \") ou par des $apostrophes$ (' ... '). Voici un dialogue qui montre  notamment comment écrire des apostrophes ou des guillemets :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le voilà qui s'approche\n",
      "\"Salut\", c'est moi\n",
      "T'es qui, toi ?\n"
     ]
    }
   ],
   "source": [
    "off1='Le voilà qui s\\'approche'\n",
    "dial1=\"\\\"Salut\\\", c\\'est moi\"\n",
    "dial2='T\\'es qui, toi ?'\n",
    "print(off1)\n",
    "print(dial1)\n",
    "print(dial2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les $chaînes$ peuvent se concaténer : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha_1= abcdef \n",
      "     alpha_1 est une chaîne : <class 'str'>\n",
      "vous avez vu comment on peut passer à la ligne ? ; ceux qui connaissent C ne sont pas surpris\n",
      "et maintenant je vais sauter deux lignes \n",
      "\n",
      "\n",
      "et voilà ! \n",
      " Bon, revenoons aux alpha_i et à la concaténation \n",
      "\n",
      "Voilà enfin un alpahbet complet :  abcdefghijklmnopqrstuvwxyz\n"
     ]
    }
   ],
   "source": [
    "alpha_1='abcdef'\n",
    "alpha_2='ghijklm'\n",
    "alpha_3='nop'\n",
    "alpha_4='qrstuvwxyz'\n",
    "print(\"alpha_1=\",alpha_1,\"\\n     alpha_1 est une chaîne :\", type(alpha_1))\n",
    "print('vous avez vu comment on peut passer à la ligne ? ; ceux qui connaissent C ne sont pas surpris')\n",
    "print('et maintenant je vais sauter deux lignes \\n\\n')\n",
    "print(\"et voilà ! \\n Bon, revenoons aux alpha_i et à la concaténation \\n\")\n",
    "alphabet=alpha_1+alpha_2+alpha_3+alpha_4\n",
    "print(\"Voilà enfin un alpahbet complet : \", alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans une $chaîne$, chaque caractère à une place précise, donné par son indice. ATTENTION : le premier indice est 0 (règle générale pour les $\\texttt{sequences}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b g t z\n"
     ]
    }
   ],
   "source": [
    "print(alphabet[0],alphabet[1],alphabet[6],alphabet[19],alphabet[25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-f2054f76c850>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0malphabet\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m26\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "alphabet[26]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'indice 26 n'existe pas car $alphabet$ ne contient que 26 caractères (et on commence à 0). Il y a une commande simple et très utile pour connaître le nombres d'indices affectés :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et on peut sélectionner les indices que l'on veut dans une $chaîne$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " qui s'app\n",
      "defghijklm\n",
      "abc\n",
      "tuvwxyz\n"
     ]
    }
   ],
   "source": [
    "print(off1[8:18])\n",
    "print(alphabet[3:13])\n",
    "print(alphabet[:3])\n",
    "print(alphabet[19:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi compter à partir de la droite : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n",
      "a\n",
      "vwxyz\n",
      "abcdefghijklmnopqrstu\n",
      "alphabet est égal à alphabet[:-5] + alphabet[-5:] ?  True\n"
     ]
    }
   ],
   "source": [
    "print(alphabet[-2])\n",
    "print(alphabet[-26])\n",
    "print(alphabet[-5:])\n",
    "print(alphabet[:-5])\n",
    "print('alphabet est égal à alphabet[:-5] + alphabet[-5:] ? ', alphabet==alphabet[:-5]+alphabet[-5:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u\n",
      "zun-de-plus\n"
     ]
    }
   ],
   "source": [
    "alphabet=alphabet+'un-de-plus'\n",
    "print (alphabet[26])\n",
    "print(alphabet[25:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observez le résultat des deux lignes de commmandes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15, '78')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=int(\"7\")+int(\"8\")\n",
    "b=str(7)+str(8)\n",
    "a,b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que font les instructions int et str ? (si ce n'est pas clair, vérifier quels sont les types de a et b)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L'instruction conditionnelle while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette instruction $\\texttt{while}$ (ou $\\texttt{tant que}$) permet de répéter une opération tant qu'une certaine condition est vérifiée. Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "while (n<20):    # Ne pas oublier le double-point !!!\n",
    "    n=2*n        # Ne pas oublier l'indentation !!!\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On notera l'importance des indentations. Certains éditeurs feront d'eux-mêmes des indentations mais, même si c'est le cas, le résultat dépend de la disposition des indentations dans le texte :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "while (n<20):   \n",
    "    n=2*n        # n double de valeur\n",
    "print(n)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et parfois, le code ne sera tout simplement pas exécutable si les indentations ne sont pas respectées :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-46-ad201e7a0899>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-46-ad201e7a0899>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    while (n<20):    # Ne pas oublier le double-point !!!\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "    while (n<20):    # Ne pas oublier le double-point !!!\n",
    "    n=2*n        # Ne pas oublier l'indentation !!!\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "while (n<20):    # Ne pas oublier le double-point !!!\n",
    "    n=2*n        # Ne pas oublier l'indentation !!!\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le calcul des puissances de 2 nous donne l'occasion de remarquer que $\\texttt{Python}$ n'est pas effrayé par les très très grands entiers... :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 à la puissance  10000  est égal à\n",
      " 9975315584403791924418710813417925419117484159430962274260044749264719415110973315959980842018097298949665564711604562135778245674706890558796892966048161978927865023396897263382623275633029947760275043459096655771254304230309052342754537433044812444045244947419004626970816628925310784154736951278456194032612548321937220523379935813492726611434269080847157887814820381418440380366114267545820738091978190729484731949705420480268133910532310713666697018262782824765301571340117484700167967158325729648886639832887803086291015703997099089803689122841881140018651442743625950417232290727325278964800707416960807867294069628547689884559638900413478867837222061531009378918162751364161894635355186901433196515714066620700812097835845287030709827171162319400624428073652603715996129805898125065496430120854170403802966160080634246144248127920656422030768369475743557128157555544872757101656910101465820478798232378005202922920783036022481433508257530960315502093211137954335450287303208928475955728027534125625203003759921130949029618559027222394036453197621274169610991353702236581188380423306516889353019901706598566746827311350281584968727754120890486405491645657201785938762384254928638468963216610799699938443330404184418919013821641387586136828786372392056147194866905430803711626645987406560098802089140982848737949082265629217067979931392065064092703141738324544345260523790441307911980992885061203522165291537934519659802301702486578291604336052956650451876411707769872697198857628727645255106155473660805376737412870387636993174149249170378468977823319310937284749639508286051850682216567908607155895699111491922923667220135482091425502536463874182275289317250550426493906194736964349770417173079403521979559492907572889588571809849364065729741891601040737491085929005694535614125452913408718110288737960708826857843862807452291452496230514315040767791654065050993837928117171769477704587811700422443763081321784324416759731860188646620047228123461627175200339013636918877688203363449318120518745705483359278525379549050123394940089135962976690641210977014151379704224477507338334194848998443120818156688196951686727900703818370938855527692112869749555093234109848290825742565247111184973857381534577734108841438100181388628861890682665805598405640396334740943600649321830384275819930267301148935778758973692623184723461543947132974108504025560161182748144084517869560684169196795878209366925255485135806957719795495799077327208668155828468015561124968984999613390866179011555931322287649567879087504099919618142307624940544480116122181086885809043178507734242029311164896426937811743278220268481311009481785514406180783756271669151635014548834325284278578752758363759449597064855668845074958090657585772003864325286594778725460165092652423556909157703662026659519231042018210881851955775319894500371426836098140451738987266660234184397934290118976109314560040371409775658974078812224149259230754852444013637360787344065797375204866057540249095227901708413474893570658031605343195755840887152396298354688\n"
     ]
    }
   ],
   "source": [
    "k=0\n",
    "while (k<10000):   \n",
    "    n=2**k # n double de valeur\n",
    "    k=k+1\n",
    "print(\"2 à la puissance \", k, \" est égal à\\n\", n)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "##  Exercice 3 - Alphabets\n",
    "\n",
    "a) A partir de la chaîne $\\texttt{abcdefghijklmnopqrstuvwxyz}$ (qu'on appellera $\\texttt{alpha}$), utiliser la boucle while pour construire une chaîne $\\texttt{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}$ (qu'on appellera $\\texttt{nouvel_alpha}$).\n",
    "\n",
    "b) Recommencer le même exercice avec la chaîne $\\texttt{saperlipopette}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 4 -  Tables de multiplication \n",
    "\n",
    "a) Utiliser la boucle while pour afficher la table de multiplication de 6 sous la forme :\n",
    "\n",
    "1 x 6 = 6\n",
    "2 x 6 = 12\n",
    "3 x 6 = 18\n",
    "etc...\n",
    "\n",
    "jusqu'à 10 x 6 =60\n",
    "\n",
    "b) Sur le même modèle, utiliser deux boucles while pour afficher les tables de multiplication de 2 à 12 ; les tables de multiplications de deux entiers successifs seront séparées par une ligne vide.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 5 - La plus petite puissance négative de 2\n",
    "Utiliser la condition $\\texttt{while}$ pour trouver le plus petit réel strictement positif de la forme $1/2^n$ et indiquer pour quel entier $n$ il est atteint. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 6 - Les nombres de Fibonacci\n",
    "\n",
    "On rappelle que la suite de Fibonacci est définie par $F(0)=F(1)=1$ et $F(n+2)=F(n)+F(n+1)$.\n",
    "\n",
    "a) Utiliser la boucle $\\texttt{while}$ pour calculer $F(100)$.\n",
    "\n",
    "b) Trouver le plus grand entier $n$ tel que $F(n)<10^{20}$ puis afficher $n$ et $F(n)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 7 - Calcul du pgcd\n",
    "\n",
    "Pour obtenir le PGCD de a et de b, on effectue la division euclidienne $a=b*q_1+r_1$, puis $b=r_1*q_2+r_2$, puis $r_1=r_2*q_2+r_3$, etc... Le dernier reste non nul dans cette suite de divisions est le PGCDde a et b. Utiliser l'instruction $\\texttt{while}$ pour calculer le PGCD de 573804 et 348096 à l'aide de cette méthode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}