{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# 1A.1 - Variables, boucles, tests\n", "\n", "R\u00e9p\u00e9titions de code, ex\u00e9cuter une partie plut\u00f4t qu'une autre."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["Plan\n", "
run previous cell, wait for 2 seconds
\n", ""], "text/plain": [""]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 1 : variables, int, float, str, list"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Un algorithme manipule des donn\u00e9es. Ces donn\u00e9es ne sont pas connues au moment o\u00f9 on \u00e9crit l'algorithme. Les variables servent \u00e0 nommer ces donn\u00e9es afin de pouvoir \u00e9crire cet algorithme. On proc\u00e8de la plupart du temps dans l'ordre suivant :\n", "\n", "* On \u00e9crit l'algorithme.\n", "* On affecte des valeurs aux variables.\n", "* On ex\u00e9cute l'algorithme.\n", "\n", "Quelques exemples \u00e0 essayer autour des variables :"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/plain": ["(3, 3.3, 'exemple', None, ' exemple sur\\nplusieurs lignes')"]}, "execution_count": 3, "metadata": {}, "output_type": "execute_result"}], "source": ["i = 3 # entier = type num\u00e9rique (type int)\n", "r = 3.3 # r\u00e9el = type num\u00e9rique (type float)\n", "s = \"exemple\" # cha\u00eene de caract\u00e8res = type str (exemple n'est pas une variable)\n", "s = 'exemple' # \" et ' peuvent \u00eatre utilis\u00e9es pour d\u00e9finir une cha\u00eene de caract\u00e8res\n", "sl = \"\"\" exemple sur\n", "plusieurs lignes\"\"\" # on peut d\u00e9finir une cha\u00eene sur plusieurs lignes avec \"\"\" ou ''' \n", "n = None # None signifie que la variable existe mais qu'elle ne contient rien\n", " # elle est souvent utilis\u00e9e pour signifier qu'il n'y a pas de r\u00e9sultat\n", " # car... une erreur s'est produite, il n'y a pas de r\u00e9sultat\n", " # (racine carr\u00e9e de -1 par exemple)\n", " \n", "i,r,s,n, sl # avec les notebooks, le dernier print n'est pas n\u00e9cessaire, il suffit d'\u00e9crire\n", " # i,r,s,n"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["anything\n"]}, {"data": {"text/plain": ["(5, 6)"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["v = \"anything\" # affectation\n", "print ( v ) # affichage\n", "v1, v2 = 5, 6 # double affectation\n", "v1,v2"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Par d\u00e9faut, le notebook affiche le r\u00e9sultat pr\u00e9sent sur la derni\u00e8re ligne de la cellule. S'il on souhaite en afficher plusieurs, il faut utiliser la fonction [print](https://docs.python.org/3/library/functions.html?highlight=print#print)."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["3\n"]}, {"data": {"text/plain": ["15"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["x = 3\n", "print(x)\n", "y = 5 * x\n", "y"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["'addition de 4 et 5 donne : 4 + 5 = 9'"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["x,y = 4,5 \n", "s = \"addition\"\n", "\"{3} de {0} et {1} donne : {0} + {1} = {2}\".format (x,y,x+y,s)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["La derni\u00e8re \u00e9criture permet d'assembler diff\u00e9rentes valeurs en une seule cha\u00eenes de caract\u00e8res. C'est tr\u00e8s pratique lorsqu'on veut r\u00e9p\u00e9ter le m\u00eame assemblage un grand nombre de fois. Ce m\u00e9canisme ressemble \u00e0 celui des lettres type : c'est un texte \u00e0 trou qu'on remplit avec des valeurs diff\u00e9rentes \u00e0 chaque fois."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Monsieur xavier, vous avez gagn\u00e9...\n", "Monsieur sloane, vous avez gagn\u00e9...\n"]}], "source": ["for prenom in [ \"xavier\", \"sloane\"] :\n", " print (\"Monsieur {0}, vous avez gagn\u00e9...\".format(prenom))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Type d'une variable :**"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\n", "True\n"]}], "source": ["print ( type ( v ) ) # affiche le type d'une variable\n", "print ( isinstance (v, str) ) # pour d\u00e9terminer si v est de type str"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Les tableaux ou listes (list) :**"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/plain": ["((4, 5), [4, 5, 6.5], 4, 5, [])"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["c = (4,5) # couple de valeurs (ou tuple)\n", "l = [ 4, 5, 6.5] # listes de valeurs ou tableaux\n", "x = l [0] # obtention du premier \u00e9l\u00e9ment de la liste l\n", "y = c [1] # obtention du second \u00e9l\u00e9ment\n", "le = [ ] # un tableau vide\n", "c,l,x,y,le"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[4, 8, 5, 6, 7]\n"]}, {"data": {"text/plain": ["[6, 7]"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ 4, 5 ]\n", "l += [ 6 ] # ajouter un \u00e9l\u00e9ment\n", "l.append ( 7 ) # ajouter un \u00e9l\u00e9ment\n", "l.insert (1, 8) # ins\u00e9rer un \u00e9l\u00e9ment en seconde position\n", "print(l)\n", "del l [0] # supprimer un \u00e9l\u00e9ment\n", "del l [0:2] # supprimer les deux premiers \u00e9l\u00e9ments\n", "l"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Longueur d'une liste et autres :**"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["3\n", "6\n"]}, {"data": {"text/plain": ["[4, 5, 6, 4, 4, 5, 6]"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ 4, 5, 6 ]\n", "print ( len(l) ) # affiche la longueur du tableau\n", "print ( max(l) ) # affiche le plus grand \u00e9l\u00e9ment\n", "s = l * 3 # cr\u00e9ation de la liste [ 4, 5, 6, 4, 5, 6, 4, 5, 6 ]\n", "t = s [ 4:7 ] # extraction de la sous-liste de la position 4 \u00e0 7 exclu\n", "s [4:7] = [ 4 ] # remplacement de cette liste par [ 4 ]\n", "s"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Type **mutable** et **immutable** (voir aussi [Qu'est-ce qu'un type immuable ou immutable ?](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/all_FAQ.html#qu-est-ce-qu-un-type-immuable-ou-immutable)) : une liste est un type **mutable**. Cela veut dire que par d\u00e9faut, l'instruction ``list1=list2`` ne recopie pas la liste, elle lui donne un autre nom qui peut \u00eatre utilis\u00e9 en m\u00eame temps que le premier."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["([-1, 1, 2], [-1, 1, 2])"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["l1 = [ 0, 1 ,2 ]\n", "l2 = l1\n", "l2[0] = -1\n", "l1,l2"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Les deux listes sont en apparence modifi\u00e9es. En fait, il n'y en a qu'une. Pour cr\u00e9er une copie, il faut explicitement demander une copie."]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/plain": ["([0, 1, 2], [-1, 1, 2])"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["l1 = [ 0, 1 ,2 ]\n", "l2 = list(l1)\n", "l2[0] = -1\n", "l1,l2"]}, {"cell_type": "markdown", "metadata": {}, "source": ["C'est un point tr\u00e8s important du langage qu'il ne faut pas oublier. On retrouve cette convention dans la plupart des [langages interpr\u00e9t\u00e9s](http://en.wikipedia.org/wiki/Interpreted_language) car faire une copie alourdit le temps d'ex\u00e9cution."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 2 : Tests\n", "\n", "Les tests permettent de faire un choix : selon la valeur d'une condition, on fait soit une s\u00e9quence d'instructions soit une autre."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["v est \u00e9gal \u00e0 2\n"]}], "source": ["v = 2\n", "if v == 2 :\n", " print (\"v est \u00e9gal \u00e0 2\")\n", "else :\n", " print (\"v n'est pas \u00e9gal \u00e0 2\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["La clause ``else`` n'est obligatoire :"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["v est \u00e9gal \u00e0 2\n"]}], "source": ["v = 2\n", "if v == 2 :\n", " print (\"v est \u00e9gal \u00e0 2\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Plusieurs tests encha\u00een\u00e9s :"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["v est \u00e9gal \u00e0 2\n"]}], "source": ["v = 2\n", "if v == 2 :\n", " print (\"v est \u00e9gal \u00e0 2\")\n", "elif v > 2 :\n", " print (\"v est sup\u00e9rieur \u00e0 2\")\n", "else :\n", " print (\"v est inf\u00e9rieur \u00e0 2\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 3 : boucles"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Les boucles permettent de r\u00e9p\u00e9ter un nombre fini ou infini de fois la m\u00eame s\u00e9quence d'instructions.\n", "Quelques exemples \u00e0 essayer autour des boucles :"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["dedans 0\n", "dedans 1\n", "dedans 2\n", "dedans 3\n", "dedans 4\n", "dedans 5\n", "dedans 6\n", "dedans 7\n", "dedans 8\n", "dedans 9\n"]}, {"data": {"text/plain": ["('dehors', 9)"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["for i in range (0, 10) : # on r\u00e9p\u00e8te 10 fois\n", " print (\"dedans\",i) # l'affichage de i\n", " # ici, on est dans la boucle\n", "# ici, on n'est plus dans la boucle\n", "\"dehors\",i # on ne passe par 10"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Boucle while :**"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n"]}], "source": ["i = 0\n", "while i < 10 :\n", " print (i)\n", " i += 1"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Interrompre une boucle :**"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["0\n", "1\n", "3\n", "4\n", "5\n", "6\n"]}], "source": ["for i in range (0, 10) : \n", " if i == 2 :\n", " continue # on passe directement au suivant\n", " print (i) \n", " if i > 5 :\n", " break # interruption d\u00e9finitive"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Parcours d'une liste :** observer les diff\u00e9rences entre les trois \u00e9critures"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u00e9l\u00e9ment 0 = 5\n", "\u00e9l\u00e9ment 1 = 3\n", "\u00e9l\u00e9ment 2 = 5\n", "\u00e9l\u00e9ment 3 = 7\n"]}], "source": ["l = [ 5, 3, 5, 7 ]\n", "for i in range (0, len(l)) :\n", " print (\"\u00e9l\u00e9ment \",i, \"=\", l [ i ] ) "]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u00e9l\u00e9ment 5\n", "\u00e9l\u00e9ment 3\n", "\u00e9l\u00e9ment 5\n", "\u00e9l\u00e9ment 7\n"]}], "source": ["l = [ 5, 3, 5, 7 ]\n", "for v in l :\n", " print (\"\u00e9l\u00e9ment \", v ) "]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u00e9l\u00e9ment 0 = 5\n", "\u00e9l\u00e9ment 1 = 3\n", "\u00e9l\u00e9ment 2 = 5\n", "\u00e9l\u00e9ment 3 = 7\n"]}], "source": ["l = [ 5, 3, 5, 7 ]\n", "for i,v in enumerate(l) :\n", " print (\"\u00e9l\u00e9ment \",i, \"=\", v ) "]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Que fait le programme suivant ?**"]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["4\n", "1\n", "3\n", "2\n"]}], "source": ["l = [ 4, 3, 0, 2, 1 ]\n", "i = 0\n", "while l[i] != 0 :\n", " i = l[i]\n", " print (i) # que vaut l[i] \u00e0 la fin ?"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On peut jouer avec des cartes pour faire d\u00e9nouer le c\u00f4t\u00e9 sybillin de ce programme : [La programmation avec les cartes](http://www.xavierdupre.fr/app/code_beatrix/helpsphinx/blog/2015-09-05_jeu_pour_les_grands.html)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 4 : les listes compactes, les ensembles\n", "\n", "Plut\u00f4t que d'\u00e9crire :"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"data": {"text/plain": ["[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"]}, "execution_count": 24, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ ]\n", "for i in range (10) :\n", " l.append( i*2+1)\n", "l"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On peut \u00e9crire :"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [{"data": {"text/plain": ["[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"]}, "execution_count": 25, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ i*2+1 for i in range(10) ]\n", "l"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Quelques examples \u00e0 essayer :"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"data": {"text/plain": ["[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"]}, "execution_count": 26, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ i*2 for i in range(0,10) ]\n", "l # qu'affiche l ?"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"data": {"text/plain": ["[0, 4, 8, 12, 16]"]}, "execution_count": 27, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ i*2 for i in range(0,10) if i%2==0 ]\n", "l # qu'affiche l ?"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Les ensembles ou **set** sont des listes pour lesqueelles les \u00e9l\u00e9ments sont uniques. Si deux nombres nombres *int* et *float* sont \u00e9gaux, seul le premier sera conserv\u00e9."]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"data": {"text/plain": ["{4, 5, 6, 7, 'a', 9, 'c', 'b'}"]}, "execution_count": 28, "metadata": {}, "output_type": "execute_result"}], "source": ["l = [ \"a\",\"b\",\"c\", \"a\", 9,4,5,6,7,4,5,9.0]\n", "s = set(l)\n", "s"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 5 : recherche non dichotomique (exercice)\n", "\n", "On veut \u00e9crire quelques instructions pour trouver la position du nombre ``x = 7`` dans la liste ``l``. Il faut compl\u00e9ter le programme suivant en utilisant une boucle et un test."]}, {"cell_type": "code", "execution_count": 28, "metadata": {"collapsed": true}, "outputs": [], "source": ["l = [ 3, 6, 2 , 7, 9 ]\n", "x = 7\n", "\n", "# ......\n", "\n", "print ( position )"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 6 : Recherche dichotomique"]}, {"cell_type": "markdown", "metadata": {}, "source": ["La [recherche dichotomique](http://fr.wikipedia.org/wiki/Dichotomie) consiste \u00e0 chercher un \u00e9l\u00e9ment ``e`` dans un tableau tri\u00e9 ``l``. On cherche sa position :\n", "\n", "* On commence par comparer ``e`` \u00e0 l'\u00e9l\u00e9ment plac\u00e9 au milieu du tableau d'indice ``m``, s'ils sont \u00e9gaux, on a trouv\u00e9,\n", "* s'il est inf\u00e9rieur, on sait qu'il se trouve entre les indices 0 et ``m-1``,\n", "* s'il est sup\u00e9rieur, on sait qu'il se trouve entre les indices ``m+1`` et la fin du tableau.\n", "\n", "Avec une comparaison, on a d\u00e9j\u00e0 \u00e9limin\u00e9 une moiti\u00e9 de tableau dans laquelle on sait que ``p`` ne se trouve pas. On applique le m\u00eame raisonnement \u00e0 l'autre moiti\u00e9 pour r\u00e9duire la partie du tableau dans laquelle on doit chercher."]}, {"cell_type": "code", "execution_count": 29, "metadata": {"collapsed": true}, "outputs": [], "source": ["l = sorted( [ 4, 7, -1,3, 9, 5, -5 ] )\n", "\n", "# recherche dichotomique\n", "# la position retourn\u00e9e est correspond \u00e0 celle de l'\u00e9l\u00e9ment dans le tableau tri\u00e9"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Partie 7 : pour aller plus loin\n", " \n", "* Que fait la fonction \u00e9crite \u00e0 la question pr\u00e9c\u00e9dente lorsque l'\u00e9l\u00e9ment ne se trouve pas dans le tableau ?\n", "* Comparer le co\u00fbt d'une recherche classique et celui d'une recherche dichotomique. On appelle co\u00fbt d'un algorithme le nombre d'op\u00e9rations qu'il faut pour atteindre le r\u00e9sultats. Dans ce cas, ce co\u00fbt correspond au nombre d'it\u00e9rations, c'est-\u00e0-dire le nombre de passage dans la boucle. Comme ce co\u00fbt d\u00e9pend des donn\u00e9es en entr\u00e9e, on experime g\u00e9n\u00e9ralement ce co\u00fbt en fonction de la taille des donn\u00e9es."]}, {"cell_type": "code", "execution_count": 30, "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": 2}