{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Initiation à Python - Séance 1-1 : variable, objet et typage dynamique" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dans cette séquence, nous allons découvrir les notions de variable et d’objet ainsi que celle de typage dynamique.\n", "\n", "## Objets\n", "Python est un langage de programmation orienté objet. Revenons d’abord sur la notion d’objet, qui si elle est bien comprise facilitera votre apprentissage de Python.\n", "Dans la séance précédente, nous avons dit qu’en informatique, un objet représente un concept. Reprenons l’exemple d’un avion. Un objet avion possède\n", "\n", "Pour l’ordinateur, cet objet représente un programme qui s’exécute. Ce programme contient toutes les informations liées à cet objet, attributs et méthodes.\n", "\n", "De base, Python est capable de gérer plusieurs types d’objets simples que nous allons découvrir. Prenons l’exemple d’une chaîne de caractères, la chaîne “bonjour” que l’on délimite en Python par des guillemets. \n", "Taper cette chaîne dans la cellule suivante et exécutez la cellule." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'bonjour'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"bonjour\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Au moment de l'exécution, Python reconnaît l’instruction comme une chaîne de caractères - c’est ce qu’on appelle le typage dynamique - et crée dans la mémoire de l’ordinateur un objet de type chaîne de caractères. Cet objet contient d’emblée plusieurs informations : d’abord un attribut qui contient l’information “bonjour”, pour simplifier appelons cet attribut valeur. La valeur de ce nouvel objet est “bonjour”. Mais également, puisque cet objet est de type chaîne de caractères, Python lui attribue toutes les méthodes associées aux objets de type chaîne de caractères - c’est-à-dire un jeu de fonctions qui va pouvoir s’appliquer à cet objet.\n", "Parmi ces méthodes, on trouve par exemple la méthode upper() qui si elle est appliquée à la chaîne “bonjour” va réécrire sa valeur en majuscules. Comment utilise-t-on ces méthodes ? Tout simplement en les accolant à un objet et en les faisant précéder d’un point. Placez-vous dans la cellule suivante et exécutez-là. Retenez que le point est une manière générique d’appeler une méthode sur un objet.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'BONJOUR'" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"bonjour\".upper()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Variables\n", "Dans la mémoire de l’ordinateur, un objet est référencé par une adresse mémoire. Une adresse mémoire est un nombre entier naturel codé sur un certain nombre de bits qui désigne une zone particulière de la mémoire.\n", "Heureusement, lorsque l’on programme, on ne manipule pas les objets à travers ces adresses, mais grâce à des variables. Pour affecter un objet à une variable, on utilise le signe égal. Dans l'exemple suivant, au moment de l'exécution, Python effectue trois choses : il crée une variable a dans l’espace des variables ; il crée un objet de type chaîne de caractères ; il référence l’objet dont la valeur est ‘bonjour’ grâce à la variable a. " ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": true }, "outputs": [], "source": [ "a = \"bonjour\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "À chaque fois que l’on utilisera la variable *a* dans une instruction Python, c’est de l’objet référencé par *a* qu’il s’agira.\n", "\n", "La variable référence un objet de type *chaîne de caractères*. On peut appliquer à cet objet la méthode *upper()* par le biais de la variable a qui référence cet objet.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'BONJOUR'" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a.upper()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Les variables n’ont pas de type ; elles ne contiennent pas d’objet, mais référencent des objets qui eux ont un type. \n", "\n", "Si l’on écrit maintenant a = 1, Python effectue plusieurs choses : il crée en mémoire un objet de type entier ; il supprime la référence entre *a* et l’objet dont la valeur est ‘bonjour’ et crée une nouvelle référence entre *a* et l’objet entier $1$. La mémoire nécessaire pour stocker ‘bonjour’ est récupérée.\n", "\n", "L’instruction *b=a*, crée une autre variable *b*, mais ne recrée par l’objet $1$. *b* et *a* référencent le même objet $1$.\n", " \n", "Un petit mot sur la fonction *print()*. La fonction *print()* d’une variable affiche à l’écran la valeur d’un objet référencé par cette variable. \n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "a = 1\n", "b = a\n", "print(b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Noms de variables\n", "Quelques règles concernant les noms que l’on peut utiliser pour les variables. Un nom de variable peut être une suite quelconque de caractères alphanumériques, c’est-à-dire les lettres de l’alphabet en minuscules, en majuscules et les chiffres Romains. Un nom de variable peut contenir aussi le tiret bas. Un nom de variable doit commencer par une lettre ou par le tiret bas.\n", "\n", "**Attention** : certains noms sont réservés : ils correspondent à des mots-clés utilisés par Python. En voici quelques-uns : **and**, **as**, **assert**, **print**, **return**.\n", "Attention à ne pas commettre d'erreur !\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m and = 4\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "and = 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Les noms de variable sont sensibles à la casse. Attention à ne pas commettre l'erreur ci-dessous !" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "ename": "NameError", "evalue": "name 'maVariable' 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\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mmavariable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmaVariable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'maVariable' is not defined" ] } ], "source": [ "mavariable = 3\n", "print(maVariable)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Kernel interrupt\n", "\n", "Si IPython Notebook semble bloqué, peut être qu'il tourne indéfiniment en raison, par exemple, d'une boucle mal contrôlée (consommant 100% de CPU d'1 core de votre machine). Vous deviez voir le message \"Kernel busy\" au haut de l'écran. Pour l'interrompre, cliquez sur le bouton [Interrupt] (ou menu Kernel>Interrupt). Si ça ne fonctionne vraiment pas, il faudra se résoudre à tuer le serveur web avec " ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# Do nothing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "while True:\n", " # Do nothing\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les types de base\n", "\n", "Dans python il y a plusieurs types de base :\n", "* Booléen : *bool*\n", "* Entier : *int* et *long*\n", "* Flottants : *float*\n", "* Complexes : *complex*\n", "* Chaînes de caractères : *str*\n", "\n", "Le type d'un objet peut être obtenu grâce à la fonction *type*. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "a = (1==2)\n", "print(a)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(1+2+3)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(1+2+3.)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# le type long a été supprimé en python 3\n", "# http://www.python.org/dev/peps/pep-0237\n", " \n", "type(2**1000) " ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(2 + 3j)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(\"bonjour\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Opérations avec les booléens\n", "\n", "\n", "| Opérations | Résultats |\n", "|------------|-----------|\n", "| x or y | Si x est faux, alors y, sinon x |\n", "| x and y | Si x est faux, alors x, sinon y |\n", "| not x | Si x est faux, alors True, sinon False |\n", "\n", "\n", "### Opérations dont le résultat est un booléen\n", "\n", "| Opérations | Interprétation |\n", "|------------|-----------|\n", "| < | inférieur strict |\n", "| <= | inférieur ou étal |\n", "| > | supérieur strict |\n", "| >= | supérieur ou égal |\n", "| == | égal |\n", "| != | différent |\n", "| is | object identique |\n", "| is not | object non identique |\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Les comparaison peuvent être enchainnées\n", "\n", "1 < 4 > 2" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "### Opérations avec les entiers (python 3)\n", "\n", "|opérateur | type du résultat |\n", "|----------|------|\n", "| \\_ + \\_ | int, int -> int |\n", "| \\_ - \\_ | int, int -> int |\n", "| \\_ * \\_ | int, int -> int |\n", "| \\_ / \\_ | int, int -> int ou float|\n", "| \\_ % \\_ | int, int -> int |\n", "| \\_ // \\_ | int, int -> int |\n", "| \\*\\* | int, int -> int |\n", "| abs(_) | int -> int |\n", "| int(_) | -> int |\n", "| cmp(_,_) # enlevé en python 3 | bool | " ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.625\n", "0\n", "1.6\n", "1\n", "1\n" ] } ], "source": [ "print(5/8)\n", "print(5//8)\n", "print(8/5)\n", "print(8//5)\n", "print(13%4)\n", "# print(cmp(4,8)) # enleve en python 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Opérations avec les flottants (python 3)\n", "\n", "|opérateur | type du résultat |\n", "|----------|------|\n", "| \\_ + \\_ | float, float -> float |\n", "| \\_ - \\_ | float, float -> float|\n", "| \\_ * \\_ | float, float -> float |\n", "| \\_ / \\_ | float, float -> float |\n", "| \\_ \\*\\* \\_ | float, float -> float |\n", "| round(_,_) | float, int -> float |\n", "| float(_) | * -> float |\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "3\n", "4\n" ] } ], "source": [ "print(round(3.14))\n", "import math\n", "print(math.floor(3.14))\n", "print(math.ceil(3.14))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Complexes" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 4+3j\n", "type(a)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n", "3.0\n", "(4-3j)\n" ] } ], "source": [ "print(a.real)\n", "print(a.imag)\n", "b = a.conjugate()\n", "print(b)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(4+3j)\n", "\n", "22\n", "\n" ] } ], "source": [ "# Attention à la syntaxe\n", "j = 6\n", "a = 4+3j\n", "print(a)\n", "print(type(a))\n", "a = 4 + 3*j\n", "print(a)\n", "print(type(a))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Chaînes de caractères\n", "\n", "|opérateur | type du résultat | commentaire |\n", "|----------|------|------------------|\n", "| \\_ + \\_ | str, str -> str | concaténation |\n", "| \\_ [ \\_ ] | str, int -> str | chaîne d'un caractère |\n", "| \\_ [ \\_ : \\_ ] | str,int,int -> str| sous-chaîne entre d et f-1 |\n", "| \\_ [: \\_ ] | str,int -> str| sous-chaîne jusqu'à f-1 |\n", "| \\_ [ \\_ : ] | str,int -> str| sous-chaîne depuis d|\n", "| len( \\_ ) | str -> int | longueur |\n", "| str( \\_ ) | -> str | conversion en chaîne |\n", "\n", "\n", "Plus d'information sur l'encodage unicode [ici](http://www.unicode.org/charts/)\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Andre Malraux\n" ] } ], "source": [ "a = \"Andre\"\n", "b = \"Malraux\"\n", "print(a+\" \"+b)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['__add__',\n", " '__class__',\n", " '__contains__',\n", " '__delattr__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__getitem__',\n", " '__getnewargs__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__iter__',\n", " '__le__',\n", " '__len__',\n", " '__lt__',\n", " '__mod__',\n", " '__mul__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__rmod__',\n", " '__rmul__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " 'capitalize',\n", " 'casefold',\n", " 'center',\n", " 'count',\n", " 'encode',\n", " 'endswith',\n", " 'expandtabs',\n", " 'find',\n", " 'format',\n", " 'format_map',\n", " 'index',\n", " 'isalnum',\n", " 'isalpha',\n", " 'isdecimal',\n", " 'isdigit',\n", " 'isidentifier',\n", " 'islower',\n", " 'isnumeric',\n", " 'isprintable',\n", " 'isspace',\n", " 'istitle',\n", " 'isupper',\n", " 'join',\n", " 'ljust',\n", " 'lower',\n", " 'lstrip',\n", " 'maketrans',\n", " 'partition',\n", " 'replace',\n", " 'rfind',\n", " 'rindex',\n", " 'rjust',\n", " 'rpartition',\n", " 'rsplit',\n", " 'rstrip',\n", " 'split',\n", " 'splitlines',\n", " 'startswith',\n", " 'strip',\n", " 'swapcase',\n", " 'title',\n", " 'translate',\n", " 'upper',\n", " 'zfill']" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dir(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comparaison\n", "\n", "Attention à ne pas confonder les opérateurs **==** et **is**" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "a = 9\n", "b = a\n", "c = 9.\n", "print(a==c)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "print(a is c)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(139855931316736, 139855931316736, 139855746434200)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "id(a), id(b), id(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les types composés : collections d'objets\n", "\n", "Les types composés sont des conteneurs pour les types de base : collections. Ils ne contienent pas des objets mais des références vers les objets en question.\n", "\n", "Nous allons faire la distinction entre les collections ordonnées et les collections non ordonnées.\n", "\n", "### Collections ordonnées\n", "\n", "* list\n", "* tuple (collections non modifiables une fois définies)\n", "* chaînes de caractères\n", "\n", "### Collections non ordonnées\n", "\n", "* set (collections dans lesquelles on ne peut pas trouver deux fois le même élément)\n", "* dict (objet de type dictionnaire qui permettent d’associer une clé et une valeur à la manière par exemple d’un annuaire téléphonique qui associe un nom et un numéro)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# listes\n", "a = [2011, 2012, 2013, 2014, 2015]\n", "b = [\"Malraus\", \"Proust\", \"Gary\"]\n", "\n", "# tuple\n", "c = (\"femme\", \"homme\")\n", "\n", "# set\n", "s = {2, 4, 6} # éléments tous différents\n", "\n", "# dict\n", "d = {\"Maison\": \"056155....\", \"Travail\": \"065247...\", \n", " \"Mamie\": \"045897...\"} " ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Nous verrons également plus loin que toutes ces collections possèdent une propriété intéressante : on peut les parcourir afin d’accéder à l’ensemble des éléments." ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2011\n", "2012\n", "2013\n", "2014\n", "2015\n" ] } ], "source": [ "for i in a:\n", " print(i)\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Listes\n", "\n", "Une liste est une collection ordonnée d’éléments. C’est un simple\n", "tableau. Les listes sont des objets mutables, c’est-à-dire que leur contenu peut être modifié." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Opérations sur les listes\n", "\n", "|opérateur | type du résultat | commentaire |\n", "|----------|------|------------------|\n", "| [_,...,_] | *,...,* -> list | définition |\n", "| [ ] | -> list | création d'une liste vide |\n", "| \\_ + \\_ | list, list -> list | concaténation |\n", "| \\_ [ \\_ ] | list, int -> * | accès à un élément de la liste |\n", "| \\_ [ \\_ : \\_ ] | list, int, int -> list | sous-liste entre d et f-1|\n", "| \\_ [: \\_ ] | list, int -> list | sous-liste jusqu'à f-1|\n", "| \\_ [ \\_ : ] | list, int -> list | sous-liste depuis d |\n", "| \\_ in \\_, \\_ not in \\_ | *, list -> bool | vérifier si la liste contient un élément donné|\n", "| all( \\_ ) | list -> bool | vérifier si tous les éléments sont égaux à True |\n", "| any( \\_ ) | list -> bool | vérifier si au moins un élément est True |\n", "| len( \\_ ) | list -> int | longueur de la liste |\n", "| str( \\_ ) | list -> string | conversion en chaîne |\n", "\n" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2011, 2012, 2013, 2014, 2015, 2016, 2017]\n", "2013\n", "[2011, 2012, 2013]\n", "False\n", "5\n" ] } ], "source": [ "print(a + [2016, 2017])\n", "print(a[2])\n", "print(a[:3])\n", "print(2017 in a)\n", "print(len(a))" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'[2011, 2012, 2013, 2014, 2015]'" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "str(a)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1900, 2012, 2013, 2014, 2015]\n" ] } ], "source": [ "a[0] = 1900\n", "print(a)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[2011, 2012, 2013, 2014, 2015]" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[i for i in range(2011, 2016)]" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[2011, 2013, 2015]" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[i for i in range(2011, 2016, 2)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Chaîne de caractères\n", "\n", "Une chaîne de caractères est une liste dans laquelle chaque caractère de la chaîne est associé à un entier, en commençant par zéro. On peut même étendre ce tableau vers la gauche avec des index négatifs." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "r\n", "A\n" ] } ], "source": [ "a = \"Andre\"\n", "print(a[3])\n", "print(a[-5])" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ndr\n" ] } ], "source": [ "print(a[1:4])" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La chaîne de caractères est certes un type de base, mais peut être vue également comme une collection ordonnée et non mutable de caractères. On peut bien entendu ajouter un caractère (ou une autre chaîne) par concaténation à une chaîne existante, mais le résultat est\n", "la création d’une nouvelle chaîne à une nouvelle adresse en mémoire." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'d'" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[2]" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "a[2] = 'c'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tuples\n", "\n", "Une tuple est une collection un peu particulière, puisqu'elle est non mutable (non modifiable). Non mutable, signifie qu'une fois définie ses éléments ne supportent pas la réaffectation. En\n", "revanche, ses éléments mutables peuvent être modifiés, comme dans l'exemple suivant où le troisième élément est une liste.\n", "**Intérêt :** l’assurance qu'elle ne sera pas modifiée par erreur dans le programme (par exemple tableau des années entre 2000 et 2050)\n", "Les opérations possibles sur les tuples sont pratiquement les mêmes que pour les listes.\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": true }, "outputs": [], "source": [ "a = (1, 'oui', 3., [5, 6, 7])" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "a[0] = 4" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[3][0]" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 'oui', 3.0, [6, 6, 7])\n" ] } ], "source": [ "a[3][0] = 6\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### set\n", "\n", "Un set est une collection dans laquelle les éléments sont\n", "uniques ; de plus cette collection n'est pas ordonnée.\n", "Que veut dire non ordonnée ? Les listes et les tuples sont des collections ordonnées dans le sens où les éléments sont à une place bien particulière définie par leur indice et c'est d'ailleurs par leur indice qu'on peut les retrouver. Dans un set, nous n'avons pas cette possibilité.\n", "L'intérêt des sets réside dans certaines opérations. \n", "\n", "#### Opérations sur les sets\n", "\n", "|opérateur | type du résultat | commentaire |\n", "|----------|------|------------------|\n", "| [$e_1$,...,$e_n$] | *,...,* -> set | définition |\n", "| set( \\_ ) | list -> set | définition à partir d'une liste |\n", "| set( \\_ ) | table -> set | définition à partir d'un dictionnaire |\n", "| set( \\_ ) | str -> set | définition à partir d'un string |\n", "| \\_ | \\_ | set, set -> set | union |\n", "| \\_ & \\_ | set, set -> set | intersection |\n", "| \\_ - \\_ | set, set -> set | différence |\n", "| \\_ ^ \\_ | set, set -> set | différence symétrique |\n", "| \\_ in \\_, \\_ not in \\_ | *, set -> bool | vérifier si le set contient un élément donné |\n", "| all( \\_ ) | set -> bool | vérifier si tous les éléments sont égaux à True |\n", "| any( \\_ ) | set -> bool | vérifier si au moins un élément est True |\n", "| \\_.issubset( \\_ ) | set, set -> bool | vérifier si un ensemble est inclus d'un autre |\n", "| len( \\_ ) | set -> int | nombre d'éléments |\n", "| str( \\_ ) | set -> string | conversion en chaîne |\n", "\n", "On voit qu'il est également possible de créer un set à partir d'un objet chaîne de caractères et d'un objet table." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": true }, "outputs": [], "source": [ "a = {2, 4, 6}" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "set" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{1, 2, 3}\n" ] } ], "source": [ "a = [1, 2, 3, 1]\n", "b = set(a)\n", "print(b)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ { "ename": "TypeError", "evalue": "'set' object does not support indexing", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing" ] } ], "source": [ "b[2]" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{1, 5, 6, 7, 12}\n", "{5, 6}\n", "{1, 12}\n", "{1, 7, 12}\n" ] } ], "source": [ "# Opérations sur les sets\n", "print({1, 5, 12, 6} | {5, 6, 7})\n", "print({1, 5, 12, 6} & {5, 6, 7})\n", "print({1, 5, 12, 6} - {5, 6, 7})\n", "print({1, 5, 12, 6} ^ {5, 6, 7})" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n" ] } ], "source": [ "print({1, 6}.issubset({1, 5, 12, 6}))\n", "print({0, 1, 6}.issubset({1, 5, 12, 6}))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### dict\n", "\n", "Une table (autrement appelée dictionnaire) définit une collection non\n", "ordonnée d'éléments ou plutôt de couples au sein desquels, l'un des deux (appelé clé) va permettre de retrouver le second (appelé valeur).\n", "Pour comprendre cette logique, il faut penser à un annuaire téléphonique, dans lequel les entrées (les clés) sont les noms de personnes, et la valeur leur numéro.\n", "\n", "#### Opérations sur les tables\n", "\n", "|opérateur | type du résultat | commentaire |\n", "|----------|------|------------------|\n", "| {$x_1$ : $v_1$, ..., $x_n$ : $v_n$} | dict | définition, associe $v_i$ à $x_i$ |\n", "| \\_ [ \\_ ] | dict, \\* -> \\* | valeur associée à la clé |\n", "| \\_ in \\_ , \\_ not in \\_| \\*, dict, -> bool | contenance de la clé |\n", "| len( \\_ ) | dict -> int | nombre d'éléments |\n", "| str( \\_ ) | dict -> string | conversion en chaîne |\n", "\n", "\n", "On remarquera qu'il n'existe aucune opération de concaténation de tables.\n", "\n", "Signalons deux méthodes importantes d'un objet de type *dic* :\n", "* La méthode *keys()* qui permet de créer la liste de toutes les clés.\n", "* La méthode *values()* qui permet de créer la liste de toutes les valeurs.\n" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": true }, "outputs": [], "source": [ "a = {\"Maison\": \"056155....\", \"Travail\": \"065247...\", \n", " \"Mamie\": \"045897...\"} " ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dict" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": true }, "outputs": [], "source": [ "b = {1:\"oui\", 6.:(9, 6), \"Mamie\":{\"non\":6}}" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'056155....'" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[\"Maison\"]" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(9, 6)" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b[6.]" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dict_keys(['Maison', 'Travail', 'Mamie'])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a.keys()" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dict_values(['056155....', '065247...', '045897...'])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a.values()" ] }, { "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.0" } }, "nbformat": 4, "nbformat_minor": 1 }