PY01_Debuter_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> <font color=\"red\">Débuter avec </font></h1>\n",
    "\n",
    "![logo Python](python-logo.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">I : Types de base et intéractions avec l'utilisateur</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">a : Objets et opérations</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, tout est objet. par exemple, dans la cellule suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5\n",
    "\"Toto\"\n",
    "True\n",
    "4.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "on a crée 4 objets différents, présents dans ce qu'on appelle l'**espace des objets**. En déclenchant la cellule précédente ( *CTRL+Entrée*), on obtient cependant que l'affichage de `4.5`. En effet, un mécanisme existant dans tous les langages de programmation, appelé **garbage collector** ( soit *collecteur d'ordure*), nettoie tout objet non utilisé. La mémoire de l'ordinateur étant limitée physiquement, il est nécessaire de nettoyer très régulièrement ( plusieurs centaines de fois par seconde) cette mémoire afin de garantir le bon fonctionnement de la machine. Le garbage collector a donc supprimé les objets `5`, `\"Toto\"` et `True`.\n",
    "\n",
    "Regardons plus précisemment ces objets, en demandant à Python grâce aux instructions **built-in** `print()` et `type()` la nature des objets crées (vous pouvez éditer, modifier, compléter à loisir les cellules IPython ci-dessous ):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les types basiques de Python sont donc les suivants :\n",
    "* le type `int` : qui permet de manipuler des nombres entiers relatifs, de $-2.10^{9}$ à $+2.10^9$;\n",
    "* le type `float` : qui permet de manipuler des nombres décimaux à $32$ bits entre $-10^{302}$ et $+10^{302}$;\n",
    "* le type `str` : qui permet de manipuler des chaînes de caractères ;\n",
    "* le type `bool` : qui permet de manipuler des valeurs **booléennes**, c'est à dire vraies ou fausses, utilisées par défaut dans les intsructions nécessitant une condition (`if` ou `while` par exemple).\n",
    "\n",
    "Chacun de ces types possède des opérations qui lui sont propres. Elles sont nombreuses, et largement documentées dans la doc Python 3 officielle, en suivant le lien ci contre : [Doc Python 3.6 en français](https://docs.python.org/fr/3.6/). \n",
    "\n",
    "Cependant nous pouvons préciser quelques opérations basiques sur les nombres :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5+2 #Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3-4 #Soustraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7*8 #Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "90/5 #Division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention ! Au résultat ci-dessus, le type obtenu est `float`, même si le résultat tombe juste... (A tester...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "16//5 #Quotient de la division euclidienne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici par contre le résultat est bien de type `int` (A tester aussi...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "16%5 #reste de la division euclidienne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5**3 #Puissance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le type `str` possède lui aussi ses propres opérations ( ou **méthodes**) qui permettent de transformer ou modifier une chaine de caractère. Parmi celles-ci, en voici quelques une utiles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Toto\"+\"Tata\" #Concaténation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Toto\"*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Toto\".replace(\"o\",\"a\") #Substitution, en utilisant le point (.) pour accéder aux méthodes de classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Toto\".lower() #mise en minuscule, appel encore une fois à une méthode de classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Toto\".upper() #mise en majuscule, idem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"une phrase SANS QUEUE ni tÊte.\".capitalize()\n",
    "#Met en majuscule le premier caractère de la chaine, et en minuscule les autres, idem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Abcdefg\"[3]#Accès direct à un caractère par son index.\n",
    "#Attention, en informatique, les index commencent à 0 dans quasiment tous les langages !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe aussi la fonction **built-in** `len()` qui donne la longueur de la chaîne de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"aeiouy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Nommage des objets</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bien entendu, de manière quasi obligatoire, il est nécessaire de conserver des objets et d'éviter que ceux-ci disparaissent avec le **garbage collector**.\n",
    "\n",
    "Pour cela, on va associer à chaque objet un **nom** dans l'**espace de nom**, grâce à l'opération d'**affectation** `=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "b=\"Toto\"\n",
    "c=True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le nom donné à l'objet peut être n'importe lequel, en respectant les règles **impératives** suivantes :\n",
    "* Un nom de variable est une séquence de lettres, de chiffres, qui ne doit pas commencer par un chiffre.\n",
    "* La **casse est significative** (les caractères majuscules et minuscules sont distingués). Donc `Joseph`, `joseph`, et `JOSEPH` sont des variables différentes.\n",
    "* Les 29 « mots réservés » du langage sont déjà pris (ex : `print()`).\n",
    "  \n",
    "Il faut également noter que les variables dont le nom commence par le caractère `_` ont une signification particulière :\n",
    "* les noms commençant par un `_` ne sont pas exportés lorsqu'ils se trouvent dans un module ;\n",
    "* les noms commençant par deux `_` et finissant par deux `_` sont réservés par le langage lui même, notamment pour la programmation orientée objet.\n",
    "\n",
    "Ces deux points ci-dessus dépassent largement le cadre de ce cours.\n",
    "\n",
    "Il existe quelques règles de \"bien nommage\" des variables :\n",
    "*  il est recommandé d'écrire les noms de variables avec une minuscule, car l'usage veut qu'on le réserve plutôt la majuscule aux noms de classes ;\n",
    "* Si le nom d'une variable doit comporter plusieurs mots, il y a deux possibilités d'écrire le nom de la variable :\n",
    "    * En **snake_case** (à la C), c'est à dire en séparant les mots par le caractère `_`. Exemple : `marge_brut`.\n",
    "    * En **camelCase** (à la Java), c'est à dire en séparant les mots par un passage en haut de casse (lettre majuscule). Exemple : `margeBrut`.\n",
    "* Il convient aussi d'éviter autant que possible l'énumération de variables (`toto1`, `toto2`, `toto3`, ...), cela rend le programme parfaitement incompréhensible et sujet à des erreurs.\n",
    "* De manière générale, il convient de suivre aussi strictement que possible les règles édictées par la **Python Software Foundation** à travers les normes PEP, dont la dernière en date est disponible ici : [PEP8](https://www.python.org/dev/peps/pep-0008/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois l'affectation réalisée, les objets sont donc récupérables grâce à leur nom, et on peut effectuer des actions sur ces objets :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Interactions avec l'utilisateur, transtypage des données, notions de formatage des chaines de caractères</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour demander une saise clavier à un utilisateur, on utilise la fonction **built-in** `input()`, prenant éventuellement en **argument**  une chaîne de caractères. Celle-ci interrompt le programme et attend une saise clavier de l'utilisateur, et retourne cette saisie sous la forme d'une chaîne de caractère.\n",
    "\n",
    "Pour afficher le contenu d'une variable, ou une chaîne de caractère, on utilise la fonction **built-in** `print()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"Entrez votre nom :\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut cependant être attentif à ce qui est réalisé par la  fonction `input()`. En effet, le **retour** effectué par cette fonction est renvoyé sous la forme de chaîne de caractères, ce qui peut poser un problème, comme par exemple dans la situation ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb=input(\"Entrez un nombre entier :\")\n",
    "print(2*nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour lever cette ambiguïté, nous sommes parfois obligés d'effectuer un **transtypage** des données, avec l'aide des fonctions **built-in** suivantes :\n",
    "* `str()`\n",
    "* `int()`\n",
    "* `float()`\n",
    "* ...\n",
    "\n",
    "En modifiant l'exemple ci-dessus :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb=input(\"Entrez un nombre entier :\")\n",
    "print(2*int(nb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "on a forcé ici dans la deuxième ligne Python à considérer le contenu de la variable `nb` comme étant un nombre entier.\n",
    "Ceci ne lève cependant pas tous les problèmes, puisque si l'utilisateur saisis une chaîne de caractères ne pouvant être transtypée en nombre entier, le programme renverra une erreur.\n",
    "\n",
    "Il est à noter qu'une solution plus élégante serait  de transtyper dès la saisie :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb=int(input(\"Entrez un nombre entier :\"))\n",
    "print(2*nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayez le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom=input(\"Saisissez votre nom :\")\n",
    "prenom=input(\"Saisissez votre nom :\")\n",
    "print(\"Votre nom de famille est {a} et votre prénom est {b}\".format(a=nom.upper(),b=prenom.capitalize()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la chaïne de caractère `\"Votre nom...\"`, on a inséré **entre accolades** deux variables `a` et `b`, qui ont été substituées grâce à la **méthode** `format()`, spécifique aux chaînes de caractères. Cette méthode est très utile pour obtenir des messages clairs pour les utilisateurs, et est fortement utilisée dès qu'il s'agit d'interfacer du HTML, du CSS ou des requêtes SQL avec du code Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">II : Structures conditionnelles et boucles</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">a : Comparateurs et opérateurs logiques</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, comme dans de nombreux langages, on utilise les comparateurs et opérateurs logiques suivants :\n",
    "* `==` : comparateur d'égalité ;\n",
    "* `!=` : comparateur de différence;\n",
    "* `<`, `<=`, `>`, `>=` : comparateurs d'ordre ;\n",
    "* `and` , `or`, `not` : opérateurs logiques et, ou et non ;\n",
    "* `in`, `notin` : opérateurs d'inclusion.\n",
    "\n",
    "Ces opérateurs renvoient une valeur **booléenne** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5==2+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4!=2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5<7<=7 # qui est très très pratique, et peu présent dans les autres langages que Python..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3<4 and 5<6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3<2 and 5<6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3<2 or 5<6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not(5<6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'toto' in 'toto va à la plage'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'z' in 'aeiouy'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Structures conditionnelles</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, on utilise pour les structures conditionnelles la syntaxe suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if condition1 :#Le : est important !\n",
    "    #bloc de une ou\n",
    "    #plusieurs lignes\n",
    "    #indentées ( avec la touche tabulation)\n",
    "elif condition2 :\n",
    "    #encore un autre bloc\n",
    "elif condition3 :\n",
    "    #etc\n",
    "    #etc\n",
    "    #etc\n",
    "else :\n",
    "    #et enfin un dernier bloc si aucune des conditions précédentes n'a été réalisée.    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les différents blocs d'instructions doivent être **correctement indentés**.\n",
    "La règle de bonne conduite est d'utiliser la touche **tabulation**, ou à défaut de respecter la norme de 4 espaces par indentation. Il est  réellement fondamental de respecter au maximum les indentations, celles-ci étant pour l'interpréteur Python le signal de déclenchement d'un bloc de code indépendant. Par exemple, le code ci-dessous renverra une erreur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb = int(input(\"Entrez un nombre entre 1 et 100 :\"))\n",
    "if nb<1 :\n",
    "    print(\"Votre nombre est trop petit\")\n",
    " elif nb>100 :\n",
    "print(\"Votre nombre est trop grand\")\n",
    "else :\n",
    "    print(\"Merci !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi noter que les mots clés `elif` et `else` sont optionnels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if nb<1 :\n",
    "    print(\"Votre nombre est trop petit !\")\n",
    "if nb>100 :\n",
    "    print(\"Votre nombre est trop grand !\")\n",
    "if 1<nb<100 :\n",
    "    print(\"Merci !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les structures conditionnelles peuvent aussi être imbriquées, en indentant à plusieurs reprises :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb=int(input(\"Entrez un nombre entier, positif ou négatif :\"))\n",
    "if nb<0 :\n",
    "    print(\"Votre nombre est positif !\")\n",
    "    if nb%2==0 :\n",
    "        print(\"Et c'est un multiple de 2 !\")\n",
    "    else :\n",
    "        print(\"Et ce n'est pas un multiple de 2 !\")\n",
    "else :\n",
    "    print(\"Votre nombre est négatif !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">c : Boucle `while`</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La boucle `while` ( ou boucle *Tant que* en pseudo-code), possède la structure suivante en Python :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while condition :#Encore une fois, ne pas oublier le signe :\n",
    "    #bloc de code\n",
    "    #indenté"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le bloc de code situé sous l'instruction `while` sera exécuté **tant que la condition donnée sera vraie**, comme dans l'exemple donné ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb= int(input(\"Donnez un nombre entier positif:\"))\n",
    "puissance = 0\n",
    "while nb//2 >=1  :\n",
    "    puissance = puissance +1\n",
    "    nb=nb//2\n",
    "print(\"Votre nombre est supérieur ou égal à 2 puissance {p} et inférieur à 2 puissance {q}\".format(\n",
    "    p=puissance,q=puissance+1))#A noter qu'ici le texte étant trop long, on a pu \"sauter\" à la ligne\n",
    "                            #le saut de ligne étant compris entre les parenthèses de la méthode format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">d : Boucle `for`</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, la boucle `for` est particulière. Elle est construite de manière à parcourir un **objet itérable**, c'est à dire un objet dont les éléments peuvent être repérés par un index, et donc qu'on peut parcourir du début à la fin.\n",
    "Ainsi, en Python, la boucle `for` peut parcourir :\n",
    "* une série de nombre entiers, grâce à la fonction **built-in**  `range()` prenant trois valeurs comme argument, la borne inférieure (incluse),la borne supérieure (exclue) et le pas ( optionnel) ;\n",
    "* une chaïne de caractère ;\n",
    "* une liste ( à voir dans le prochain cours ) ;\n",
    "* un fichier texte ( qui sera vu dans le TP crée un site web interactif avec Cherrypy );\n",
    "* un fichier binaire ( pour ceux qui veulent s'amuser, un TP sera prévu sur la Stéganographie );\n",
    "* etc.\n",
    "\n",
    "La syntaxe de la boucle `for` est la suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for variable in itérable :#Toujours ce :\n",
    "    #Bloc d'instruction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut utiliser ainsi utiliser la boucle `for` comme sur les exemples suivants :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,100) :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texte ='Un texte quelconque'\n",
    "for lettre in texte :\n",
    "    if lettre in 'aeiouy':\n",
    "        print(\"Tiens, j'ai vu la voyelle {}.\".format(lettre))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"blue\">III :Exercices</font></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">a : Exercices de base et logique</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Ecrivez un programme qui permute et affiche les valeurs de trois variables A,B et C : A va dans B, B va dans C et C dans A\n",
    "2. Ecrire un programme qui demande un nombre à l'utilisateur, puis affiche le carré de ce nombre.\n",
    "3. Ecrire un programme qui demande l'heure qu'il est ( un nombre pour les heures, un nombre pour les minutes et un pour les secondes ). Cet algorithme indiquera en outre si l'heure donnée est valide.\n",
    "4. Compléter le programme précédent afin que l'algorithme donne l'heure qu'il sera dans 10 minutes.\n",
    "5. Ecrire un programme qui demande les coefficients $a$ et $b$ d'une fonction affine, et qui donne son nombre de racines et leur valeur éventuelles. Attention aux cas particuliers !\n",
    "6. Etendre le programme précédent pour la résolution d'équations du type $ax+b = cx+d$, où $a,b,c,d$ sont des entiers saisis par l'utilisateur.\n",
    "7. Reprendre le problème n°5 pour un trinôme du second degré."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">b : Vision rapide des listes</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, il existe des types pouvant contenir d'autres variables. En particulier, dans les exercices suivant, on vous demandera de créer des objets de type **liste**.\n",
    "Une liste est définie par des crochets `[` et `]` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [] #Une liste vide\n",
    "b = [32,41,53,-7,3] #Une liste de nombres\n",
    "c = [\"toto\", \"tata\",\"tutu\"] #Une liste de chaîne de caractères\n",
    "d = [b, True, \"Truc\", 5]#une liste mixte, dont le premier élément est lui-même une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les listes sont des séries d'objets :\n",
    "* **ordonnés ** : on peut accéder a un élément à partir de son **index** ( en commençant par $0$) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **itérables** : on peut parcourir la liste avec une boucle `for`, et en particulier effectuer un test d'appartenance grâce au mot clé `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(32 in b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for mot in c :\n",
    "    print(mot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **mutables** : les élements d'une liste peuvent être changé à partir de leur position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[1]=False\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **extensibles** : on peut rajouter des éléments à une liste. Il est possible de le faire à n'importe quelle position, mais nous nous contenterons ici de ne rajouter qu'en dernière place, grâce à la **méthode** `append()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[1,2,3,4,5]\n",
    "print(\"Avant extension : {}\".format(a))\n",
    "a.append(6)\n",
    "print(\"Après extension : {}\".format(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><font color=\"green\">c : Exercices sur les boucles `for` et `while`</font></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Ecrire un programme qui les 20 premiers nombres de la table de multiplication d'un entier choisi par l'utilisateur.\n",
    "2. Ecrire un programme qui stocke dans une liste puis affiche les restes des $200$ premiers entiers de la division euclidienne par $7$.\n",
    "3. Ecrire un programme qui stocke dans une liste puis affiche les restes des $300$ premières puissances de $2$ modulo $17$. Que constate-t-on ?\n",
    "4. Ecrire un programme qui affiche une suite de 12 nombres dont chaque terme soit égal au triple du nombre précédent.\n",
    "5. On considère la suite $(u_n)$ de premier terme $u_0 = 30$ et définie par $u_{n+1}=\\dfrac{4}{5}u_n +1$.\n",
    "    1. Ecrire un programme qui calcule les 100 premiers termes de cette suite et les stocke dans une liste. Que constate-t-on ?\n",
    "    2. Ecrire un programme qui donne le premier rang $n$ tel que le terme $u_n$ soit à une distance de $5$ inférieure à une précision donnée par l'uitilisateur.\n",
    "6. Ecrire un programme qui demande un nombre entier entre 1 et 10 à l'utilisateur, et qui poursuit cette demande dans que l'utilisateur n'a pas exactement fait ce qui lui était demandé ( on appelle ce type de programme **dumbproof**). Le programme ne doit pas planter si l'utilisateur ne saisis pas un nombre entier !  On pourra utiliser le mot clé `break`, qui permet de sortir d'une boucle `for` ou `while` de manière prématurée ainsi que le bloc d'instruction :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try :\n",
    "    #bloc1\n",
    "except :\n",
    "    #bloc2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou le bloc d'instruction `bloc2` est exécuté uniquement si une erreur est soulevée dans l'exécution du bloc `bloc1`."
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}