{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Python : Révision des outils de base grâce à Jupyter notebook\n", "\n", "\n", "\n", "Ce notebook est proposé dans le cadre d'une préparation au ** Cours de mathématiques & informatique ** en B.C.P.S.T.2 - Externat des enfants nantais proposé par [J. Laurentin](). On pourra, si on le souhaite, trouver des compléments notamment sur le programme officiel en visitant le site de la classe [mathsinfo-bcpst2-eden.fr](http://mathsinfo-bcpst2-eden.fr/)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## 1. Prise en main" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Le Notebook d'IPython est un environnement intéractif pour écrire et faire tourner du code Python. \n", "Des cellules de code, précédées d'un `In []` permettent de rentrer des lignes de codes comme vous avez pu le faire jusqu'à présent dans la fenêtre de commande de Pyzo. \n", "A titre d'exemple, placez votre curseur sur la ligne ci-dessous et appuyez sur la touche ``. Vérifiez que l'instruction n'a pas été exécutée mais en revanche un saut de ligne a été inséré..." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Pour **exécuter le code** Python d'une cellule, il vous faut, au choix, taper `` ou cliquer sur le bouton [lecture] de la barre des tâches ci-dessus (ou encore utiliser le menu `Cell>Run and Select Below...`). \n", "Il suffit d'essayer :" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a*b vaut 5\n" ] } ], "source": [ "a,b = 1,5\n", "print('a*b vaut',a*b)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Il est toujours possible d'effacer une cellule grâce aux ciseaux du bandeau situé en haut de page et en créer une nouvelle grâce au symbole '+'. \n", "Mais c'est le plus souvent inutile car il est possible de relancer une ligne autant de fois qu'on le souhaite après l'avoir modifiée. \n", "Par exemple, modifiez la ligne de code `In [1]` pour initialiser la variable `b` à 5 et afficher la valeur de `a+b`. \n", "vous devriez voir afficher 'a+b vaut 6'." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "D'un point de vue pratique, on notera que toutes les fonctionnalités d'Ipython sont ici opérationnelles. \n", "On peut par exemple retrouver le chemin du dossier dans lequel on travaille :" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "'C:\\\\Users\\\\Jérôme\\\\Documents\\\\BCPST2\\\\Jupyter'" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pwd" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "On peut aussi importer les bibliothèques de son choix. \n", "Par exemple :" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "scrolled": true, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "from math import *\n", "import numpy as np" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "On peut désormais faire :" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "x = 2\n", "y = exp(x)-1" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2 | 6.38905609893065\n" ] } ], "source": [ "print(x,'|',y)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": true, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "X = np.linspace(0,1,10)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556\n", " 0.66666667 0.77777778 0.88888889 1. ]\n" ] } ], "source": [ "print(X)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Il est aussi possible d'écrire des fonctions plus complexes. \n", "Par exemple pour la suite de Fibonacci définie par $u_0=1=u_1$ et $u_{n+2}=u_{n+1}+u_n$, $\\forall n\\geq 0$ \n", "on calculera et on affichera ses dix premiers termes en écrivant :" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 1 2 3 5 8 13 21 34 55 89 144 " ] } ], "source": [ "a,b=1,1 # initialisation de deux premiers termes\n", "print(a,b,end = \" \")\n", "n=1\n", "while n<11 :\n", " a,b = b,a+b\n", " print(b,end = \" \")\n", " n = n+1" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "** Attention ** Vous noterez que tous les termes de la suite ont été affichés sur une seule ligne. \n", "Ce résultat est obtenu grâce à l'argument `end = \" \"` fourni à la fonction `print()`. \n", "Supprimez cet argument et vérifiez que les termes sont affichés les uns en dessous des autres." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## 2. Quelques éléments sur Python, langage *Orienté Objet*" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Avec Python, tout est objet : données, fonctions, modules... \n", "> Un **objet** : \n", " - possède une *identité* (à savoir une adresse mémoire); \n", " - possède un *type* : un objet est l’instanciation d’une classe qui définit son type\n", "(par exemple : int, float, str); \n", " - contient des *données* (par exemple, si c'est un objet numérique, cette donnée est sa *valeur*). \n", " \n", "> Un objet est référencé par un **identificateur** : \n", " - on trouvera également \"référence\", \"nom\", \"étiquette\", comme synonymes d'indentificateur; " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": true, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "a = 5 # a est l'identificateur et 5 est une expression évaluée comme objet." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1409942128\n", "\n" ] } ], "source": [ "# il est possible d'afficher l'identité et le type de l'objet référencé :\n", "print(id(a)) # identité\n", "print(type(a)) # type" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1409942128\n", "\n" ] } ], "source": [ "b = a # deuxième nom (étiquette ou référence) pour l'entier 5\n", "print(id(b))\n", "print(type(b))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": true, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "c = 5.0 # nouvel identificateur qui pointe cette fois vers 5.0" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(c)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1409942128 1409942128 4395697064\n" ] } ], "source": [ "print(id(a),id(b),id(c))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b # égalité des valeurs des deux objets" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == c # égalité des valeurs" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is c # test l'égalité des identités" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b # test l'égalité des identités" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "On retiendra que a, b et c ont même valeur mais que c se distingue de a et b car son identité et son type son distincts." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "** Attention ! ** Tous les objets ne sont pas modifiables ! \n", "> Un objet dont le contenu peut être changé est dit ** mutable ** (non mutable dans le cas contraire). \n", "A titre d'exemple une chaîne de caractère est un objet non mutable tandis qu'une liste est un objet mutable." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Feci est un texte non modifiable\n" ] } ], "source": [ "T = 'Feci est un texte non modifiable'\n", "print(T)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mT\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'C'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "T[0]='C'" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "[12, -5.0, 'oups']" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [12,-5.0,'oups'];L" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "[12, -5.0, 3]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L[2]=3;L" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[12, -5.0, 3]\n" ] } ], "source": [ "print(L)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "** Remarque importante ** sur les copies d'objets qui peuvent donner lieu à des erreurs difficiles à déceler :" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[12, -5.0, 3]\n" ] } ], "source": [ "M = L\n", "print(M)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[12, 60, 3]\n" ] } ], "source": [ "M[1]=60 # modification de la liste M\n", "print(M)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "La question est de savoir si la liste `L` aussi a été modifiée..." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "data": { "text/plain": [ "[12, 60, 3]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L is M # L et M ont la même identité. Ils pointent vers le même objet et il est normal que L soit modifiée également." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Il existe deux solutions pour faire la copie d'un objet : La copie * superficielle * ou la copie * profonde *. \n", "Nous verrons ça à la fin du paragraphe 3.2 * Modification d'une liste *" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## 3. Manipulation des listes :" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "slideshow": { "slide_type": "subslide" } }, "source": [ "Les **listes** représentent un type de données composées extrêment utiles sous Python. \n", "On peut les voir comme une *collection d'éléments séparés par des virgules, l'ensemble étant enfermé dans des crochets*. \n", "Les éléments peuvent être de type très différents. Par exemple :" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": true, "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "L1 = [1,2,3.5,'7',-2.4,'test']" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3.5, '7', -2.4, 'test']\n" ] } ], "source": [ "print(L1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### 3.1 Accès aux éléments d'une liste :\n", "Il est possible d'accéder à n'importe quel élément d'une liste en indiquant entre crochets l'index numérique qui correspond à la position de l'élément. \n", "Essayez successivement dans la ligne ci-dessous : `L1[2]`, `L1[0]`, `L1[5]`, `L1[-1]`, `L1[-1][1]`" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "3.5" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Obtenir un élément de la liste :\n", "L1[2]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "On obtient la **longueur** d'une liste ou d'une chaîne en faisant appel à la fonction `len()` :" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "la longueur de L1 vaut : 6\n", "la longueur de la chaîne de caractère \"test\" vaut : 4\n" ] } ], "source": [ "n1 = len(L1)\n", "print('la longueur de L1 vaut : ',n1)\n", "print('la longueur de la chaîne de caractère \"test\" vaut : ',len(L1[-1]))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Il est aussi possible de savoir si un élément est dans une liste :" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 in L1" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.5 est dans L1\n" ] } ], "source": [ "u = 3.5\n", "if u in L1:\n", " print(u,' est dans L1')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "#### On notera qu'une liste peut donc est formée de plusieurs types d'éléments. \n", "1. Les **type integer** (par exemple `L1[0]` et `L1[1]` sont des entiers).\n", "2. Les **type float** pour *floating point number* (`L1[2]` est un \"nombre réel\" ou \"nombre à virgule flottante).\n", "3. Les **type string** (`L1[3]` et `L1[5]` sont des chaînes de caractères). \n", "\n", "On obiendra le type d'un élement en faisant appel à la fonction `type()`. \n", "Par exemple on essaira ci-dessous `type(L1)`, `type(L1[0])`, `type(L1[2])` ou encore `type(L1[3])` :" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(L1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "*Remarque :* Dans le cas de `L1[3]` on vérifiera qu'il s'agit bien d'un caractère et non d'un entier ! \n", "\n", "Cela étant, il est possible d'accéder à bien mieux qu'à un seul élément d'une liste. \n", "Il est en effet possible d'extraire n'importe quelle sous-liste et ce dans l'ordre de votre choix.\n", "Commençons par extraire les trois premiers éléments de `L1` :" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3.5]\n", "[1, 2, 3.5]\n" ] } ], "source": [ "print(L1[0:3])\n", "print(L1[:3])" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "L1 vaut : [1, 2, 3.5, '7', -2.4, 'test']\n", "[2, 3.5, '7', -2.4, 'test']\n", "[2, 3.5, '7', -2.4]\n", "[2, '7']\n", "[-2.4, '7', 3.5]\n", "['test', -2.4, '7', 3.5, 2, 1]\n" ] } ], "source": [ "print('L1 vaut : ',L1)\n", "print(L1[1:])\n", "print(L1[1:-1])\n", "print(L1[1:4:2]) # index de 1 à 4 (exclus) par pas de 2.\n", "print(L1[4:1:-1]) # index de 4 à 1 (exclus) par pas de -1.\n", "print(L1[::-1]) # Affichage inversé de tout L1." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "A vous de jouer en créant à la suite de ce texte une nouvelle ligne de code (cliquer sur le symbole '+' dans le bandeau en haut de page) au sein de laquelle vous initialisez une liste `L2` de votre choix et en s'entraînant à accéder à n'importe laquelle des sous-listes possibles. \n", "\n", "** Attention ** : Respecter l'affectation de ce nom (`L2`) à la liste que vous allez créer, sans quoi les indications du paragraphe 3.2 ne coincideront plus avec la liste `L1` sur laquelle nous continuons de travailler ! \n", "Souvenez-vous qu'il est toujours possible de supprimer une ou des cellules qui ont été créées en utilisant 'Edit -> Delete Cells' ou bien la 'paire de ciseaux' des icônes ci-dessus. \n", "Il est aussi possible de réinitialiser l'ensemble des cellules, en allant dans l'onglet 'Kernel' et en exécutant 'Restart & Clear Output'. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### 3.2. Modification d'une liste :\n", "Nous rappelons que les listes sont des objets * mutables *. \n", "Si on connaît l'index d'un élément, il est facile de le changer ou de le remplacer. \n", "Par exemple :" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3.5, '7', -2.4, 'test']\n", "[1, 14, 3.5, '7', -2.4, 'test']\n" ] } ], "source": [ "print(L1)\n", "L1[1] = L1[1]+12\n", "print(L1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Vous avez dû obtenir en deuxième ligne : [1, 14, 3.5, '7', -2.4, 'test']" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Il est aussi possible de modifier le ** type ** des éléments de la liste grâce à des \"built-in function\", qu'on appellera aussi des ** *méthodes* ** ou *fonction primitives*. On trouvera parmis celles-ci `int()`, `float()`, `complex()`, `str()` ou encore `list()`, `set()`. \n", "Par exemple, pour remplacer le caractère `\"7\"` par l'entier \"7\" on fera : " ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 14, 3.5, 7, -2.4, 'test']\n" ] } ], "source": [ "L1[3]=int(L1[3]) # on écrira float(L1[3]) pour le transformer en type float.\n", "print(L1)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(L1[3])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "**Exemple d'application** de ces méthodes de changement de type (d'après *Programmation en Python pour les mathématiques*, par A. Casamayou-Boucau, P. Chauvin et G. Connan, (Dunod, 2012), p.38) : \n", "Calculer $u_n=\\cfrac{C_n}{n(n+1)}$ où $C_n$ désigne le nombre de chiffres intervant dans l'écriture décimale de $n$." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "u_ 53 vaut : 0.0006988120195667365\n" ] } ], "source": [ "n = 53\n", "print('u_',str(n),' vaut :',len(str(n))/(n*(n+1)))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Plus généralement, il est particulièrement important de savoir manipuler une liste pour insérer, supprimer un élement, ou encore concaténer des listes. \n", "Utilisez la ligne de code ci-dessous pour tester des *méthodes* particulièrement efficaces dont voici quelques exemples :" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 14, 3.5, 7, -2.4, 'test', 14]\n", "[1, 14, 3.5, 7, -2.4, 'test', 14, 14]\n" ] } ], "source": [ "L1.append(14) # ajout de 6 en fin de liste\n", "print(L1)\n", "L1 = L1+[14] # autre méthode possible...\n", "print(L1)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 14, 3.5, 54, 7, -2.4, 'test', 14, 14]\n" ] } ], "source": [ "L1.insert(3,54) # insertion de x=54 à la position i=3\n", "print(L1)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L1.index(54) # retourne l'index de la première occurence de x=54" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L1.count(14) # dénombre les x=14 présents dans L1 - essayer avec d'autres valeurs..." ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 14, 3.5, 54, 7, -2.4]\n" ] } ], "source": [ "del L1[6:] # suppression des termes indexés à partir de 7\n", "print(L1)" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-2.4, 1, 3.5, 7, 14, 54]\n", "[54, 14, 7, 3.5, 1, -2.4]\n" ] } ], "source": [ "L1.sort() # tri croissant de L1\n", "print(L1)\n", "L1.sort(reverse = True)\n", "print(L1) # tri décroissant" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "**Attention** On rappelle que les listes sont des objets *mutables*. En particulier toute méthode appliquée à une liste ne créé pas un objet nouveau mais la modifie. Vos données d'origine sont perdues ! \n", "Aussi, dans le cas du tri d'une liste, si on ne souhaite pas perdre la liste de départ, on préfèrera L1_triee = sorted(L1) qui fait une copie triée de L1 sans la modifier." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Voyons maintenant les moyens de faire la ** copie ** d'une liste - la copie * superficielle * puis la copie * profonde * :" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, [2, 3]] [10, [2, 3]]\n", "[1, [20, 3]] [10, [20, 3]]\n" ] } ], "source": [ "L = [1,[2,3]]\n", "M = list(L) # copie superficielle: M est un nouvel objet `list` initialisé par L\n", "M[0]=10\n", "print(L,M)\n", "M[1][0]=20\n", "print(L,M)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si tout se passe bien pour `M[0]`, le problème pour `M[1][0]` vient du fait que M[1] pointe vers une même liste que L[1]... \n", "Reprenons :" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, [2, 3]] [10, [2, 3]]\n", "[1, [2, 3]] [10, [20, 3]]\n" ] } ], "source": [ "L = [1,[2,3]]\n", "from copy import deepcopy\n", "M = deepcopy(L) # copie profonde : M est une copie complète de l'objet référencé par L\n", "M[0]=10\n", "print(L,M)\n", "M[1][0]=20\n", "print(L,M)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### 3.3 Création de listes particulières :" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Création d'une liste de nombres à l'aide de la fonction `range()` : \n", "Cette fonction génère par défaut une séquence de nombres entiers de valeurs croissantes à partir de 0. \n", "Cette séquence peut s'utiliser directement (par exemple pour une boucle `POUR`) ou bien être transformée en *liste* :" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(10))" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 1 4 9 16 25 36 49 64 81 " ] } ], "source": [ "for k in range(10):\n", " print(k**2,end = \" \")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Mais bien d'autres possibilités s'offrent à vous :" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(2,12))" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[2, 4, 6, 8, 10]" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(2,12,2))" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4]" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(7,-5,-1))" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[0]*10" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[4, 8, 'bip', 4, 8, 'bip', 4, 8, 'bip']" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[4,8,'bip']*3" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 0, 1, 2, 3, 4]" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(5))*2" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "On peut aussi créer des listes \"en compréhension\" :" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" ] } ], "source": [ "L = [k**2 for k in range(11)]\n", "print(L)" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 4, 16, 36, 64, 100]\n", "[36, 64, 100]\n" ] } ], "source": [ "L2 = [k**2 for k in range(11) if k%2 == 0]\n", "print(L2)\n", "L3 = [k**2 for k in range(11) if (k > 4) and (k%2 == 0)]\n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Et même créer des listes de listes, utiles pour constituer des tableaux ou des matrices :" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "L4 = [[i**2+j for i in range(3)] for j in range(2)]\n", "print(L4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "print('la première ligne vaut : ',L4[0])\n", "print('la seconde ligne vaut : ',L4[1])\n", "print('le deuxième terme de la première ligne vaut : ',L4[0][1])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Si on possède deux listes de même longueur, il est possible de les associer pour former des couples (appelés aussi `tupples`) :" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "Couleur = ['carreau','coeur','pique','treffle']\n", "Hauteur = ['Roi','Dame','Valet','As']\n", "for (c,h) in zip(Couleur,Hauteur):\n", " print(h,' de ',c)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "ou encore, si on souhaite faire le produit scalaire de deux vecteurs $u$ et $v$ :" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "u = [1,0,2]\n", "v = [-1,1,3]\n", "print(sum(x*y for x,y in zip(u,v)))" ] } ], "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.5.2" } }, "nbformat": 4, "nbformat_minor": 0 }