td0BCPST2a_introductionPython.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copie de td0BCPST2a-introductionPython.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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.6"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JLaurentin/notebooks_BCPST2_EDEN/blob/master/td0BCPST2a_introductionPython.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AWJrVyEUwoXU",
        "colab_type": "text"
      },
      "source": [
        "# Python : Révision des outils de base grâce à Jupyter notebook\n",
        "\n",
        "<img src=\"https://avatars3.githubusercontent.com/u/7388996?v=3&s=200\">\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](<j.laurentin@worldonline.fr>)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBmfQ69IcmRs",
        "colab_type": "text"
      },
      "source": [
        "## Opération préliminaire.  \n",
        "\n",
        "**Une fois connecté** (sur le bandeau, en haut à droite) commencer par enregistrer une copie de ce notebook dans votre **Drive** (\"Fichier\" + \"Enregistrer une copie dans Drive...\"\"). C'est sur **CETTE** copie que je vous suggère de travailler par la suite si vous voulez conserver vos modifications.   \n",
        "\n",
        "Une fois cette opération réalisée, vous pourrez par la suite accéder directement à vos notebooks depuis \"colab.research.google.com\" (téléphone ou ordinateur).   \n",
        "Il suffira d'aller dans l'onglet \"Fichier\" puis \"ouvrir un notebook\", pous accéder à l'ensemble des notebooks enregistrés dans **votre Drive** mais aussi les fichiers source placés sur Github.  \n",
        "\n",
        "Je vous souhaite de prendre beaucoup de plaisir grâce à ces outils de révision !"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZqQQ71uUwoXz",
        "colab_type": "text"
      },
      "source": [
        "## 1. Prise en main"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZDTttJxvwoX_",
        "colab_type": "text"
      },
      "source": [
        "Le Notebook d'IPython est un environnement intéractif pour écrire et faire tourner du code Python.  \n",
        "Il se présente sous la forme d'une succession de cellules qui contiennent soit un texte d'explication ou un code exécutable et sa sortie. Il suffit de cliquer sur une cellule pour la sélectionner.  \n",
        "Les cellules de code sont facilement identifiable car précédées d'un `[]`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BpC_jHeHwoYS",
        "colab_type": "text"
      },
      "source": [
        "Ci-dessous une cellule de code.  \n",
        "Pour **exécuter le code** Python de cette cellule, il vous faut, au choix, taper : \n",
        "\n",
        "1.  Cliquer sur le bouton \"lecture\" au début de la cellule sélectionnée.\n",
        "2. Faire `ctrl + Enter` pour exécuter la cellule en place.\n",
        "3.  Faire  `maj + Enter` pour exécuter la cellule et aller à la cellule suivante.\n",
        "4. Faire  `alt + Enter` pour exécuter la cellule et insérer une cellule de code immédiatement après.\n",
        "\n",
        "\n",
        "Il suffit d'essayer... "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RrxIZNdjwoYV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a,b = 2,3\n",
        "print('a*b vaut',a*b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sEZHfbOwoYs",
        "colab_type": "text"
      },
      "source": [
        "Il est toujours possible d'effacer l'élément de sortie  en se plaçant sur la cellule et de cliquer sur la `croix`.  \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 les lignes de code `[1]` pour initialiser la variable `b` à 5 et afficher la valeur de `a+b`.  \n",
        "vous devriez voir afficher 'a+b vaut 7'."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-rB6pUB8woYy",
        "colab_type": "text"
      },
      "source": [
        "D'un point de vue pratique, on notera que toutes les fonctionnalités d'Ipython sont ici opérationnelles.  \n",
        "On travaille de façon privilégiée avec les listes, mais il est utile d'importer certaines bibliothèques pour faire certains calculs d'analyse, d'algèbre, de probabilité ou encore proposer des représentations graphiques."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yT4uuGPSrtYi",
        "colab_type": "text"
      },
      "source": [
        "Ainsi, exécutez la ligne suivante sans importer de bibliothèque :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2oq8B5epyKu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = exp(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0EhD5Izr3Ej",
        "colab_type": "text"
      },
      "source": [
        "Un message d'erreur apparaît qui précise que cette fonction \"exp\" n'est pas définie...   \n",
        "Il suffit d'importer la bibliothèque `math` pour lever ce problème.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2yaPJZFfwoZJ",
        "colab_type": "text"
      },
      "source": [
        "Ainsi :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Fe8CRxTxwoZS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from math import *"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MeRZyaCcwoZ4",
        "colab_type": "text"
      },
      "source": [
        "On peut désormais faire :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H8evwjo9woaB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 2\n",
        "y = exp(x)-1\n",
        "print(x,'|',y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PlbRElkCwoac",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(e,'|',log(e))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3NzhGFw_sz5S",
        "colab_type": "text"
      },
      "source": [
        "On importera également la bibliothèque `numpy` comme à l'accoutumée"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJl-In-ttAye",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q_kT7mlytMd2",
        "colab_type": "text"
      },
      "source": [
        "On peut désormais créer un tableau t1 de réels compris entre `0` et `1` par pas de `0.1`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_gmEkZ-KbDpS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t1 = np.arange(0,1.1,0.1)\n",
        "print(t1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JW2dPdzvtmba",
        "colab_type": "text"
      },
      "source": [
        "ou encore créer un tableau `t2` de 10 réels compris entre `0` et `1` (compris)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n3QtA2t9woal",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t2 = np.linspace(0,1,10)\n",
        "print(t2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyRsPqRpwobb",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "NHY8UOsDwobc",
        "colab_type": "code",
        "colab": {}
      },
      "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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZWe_zqVrwobn",
        "colab_type": "text"
      },
      "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": {
        "id": "UMfNlTMMwobs",
        "colab_type": "text"
      },
      "source": [
        "## 2. Quelques éléments sur Python, langage *Orienté Objet*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q-ku43A9wobx",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "SNH8utKiwob1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 5 # a est l'identificateur et 5 est une expression évaluée comme objet."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q7BQS_e6wocV",
        "colab_type": "code",
        "colab": {}
      },
      "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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OX3cvqs9wock",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = a # deuxième nom (étiquette ou référence) pour l'entier 5\n",
        "print(id(b))\n",
        "print(type(b))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2sh6YBUBwoc0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "c = 5.0 # nouvel identificateur qui pointe cette fois vers 5.0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TqeXqXDowoc7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "urTomcpqwodK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(id(a),id(b),id(c))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CkuSMkyewodc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a == b # égalité des valeurs des deux objets"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "slHCQdhlwodo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a == c # égalité des valeurs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_uGYvCU0wodw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a is c # test l'égalité des identités"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IuJ6snw1wod2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a is b # test l'égalité des identités"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pB7BszEuwod_",
        "colab_type": "text"
      },
      "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": {
        "id": "8EGZaY8awoeC",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "HR_ENxAkwoeE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "T = 'Feci est un texte non modifiable'\n",
        "print(T)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HXDs5jcZwoeT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "T[0]='C'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5p-yrduKwoem",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L = [12,-5.0,'oups'];L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bof8rygZwoeq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L[2]=3;L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KtTZEk5owoeu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(L)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PIM2yGaiwoez",
        "colab_type": "text"
      },
      "source": [
        "**Remarque importante** sur les copies d'objets qui peuvent donner lieu à des erreurs difficiles à déceler :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DGxur0l2woe1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "M = L\n",
        "print(M)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m2L8qVdBwoe7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "M[1]=60 # modification de la liste M\n",
        "print(M)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cqq9QUyawofC",
        "colab_type": "text"
      },
      "source": [
        "La question est de savoir si la liste `L` aussi a été modifiée..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hNIy7r-gwofD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y2KZJt8jwofM",
        "colab_type": "code",
        "colab": {}
      },
      "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."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PuuKsMkUwofS",
        "colab_type": "text"
      },
      "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": {
        "id": "YrXzzOulwofV",
        "colab_type": "text"
      },
      "source": [
        "## 3. Manipulation des listes :"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "o_1n0bA2wofW",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "8FFrtHYRwofY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1 = [1,2,3.5,'7',-2.4,'test']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mszgXalOwoft",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gCRTIVrVwof2",
        "colab_type": "text"
      },
      "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.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjjLxqQLwof3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Obtenir un élément de la liste :\n",
        "print('le 3ème éléments vaut : ',L1[2])\n",
        "print('le dernier élément vaut : ',L1[-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "12-TRTROw2vP",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_4FYdMO5wvU5",
        "colab_type": "text"
      },
      "source": [
        "Essayez successivement dans la ligne ci-dessous : `L1[0]`, `L1[5]`, `L1[-1]`, `L1[-1][1]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H4dI_UmOw2Ia",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-jqFWrxwogF",
        "colab_type": "text"
      },
      "source": [
        "On obtient la **longueur** d'une liste ou d'une chaîne en faisant appel à la fonction `len()` :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oPSpuktSwogJ",
        "colab_type": "code",
        "colab": {}
      },
      "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]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JIjeYE9bwogO",
        "colab_type": "text"
      },
      "source": [
        "Il est aussi possible de savoir si un élément est dans une liste :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0iznyWFywogQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "3 in L1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fuSlC-OFwogT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "u = 3.5\n",
        "if u in L1:\n",
        "    print(u,' est dans L1')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlgHJ_q4wogg",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "RDbCXTzRwogh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1cS8RgNwogs",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "yV7S-IbVwogv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(L1[0:3])\n",
        "print(L1[:3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnFRZDBmwohG",
        "colab_type": "code",
        "colab": {}
      },
      "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."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PxfnrE4wohK",
        "colab_type": "text"
      },
      "source": [
        "A vous de jouer en créant à la suite de ce texte une nouvelle ligne de code (cliquer sur le symbole '+ Code' dans la zone intercellule ou utiliser l'onglet \"insérer\") 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 'Modifier' ou bien les \"trois petits points situés en fin de cellule\".  \n",
        "Il est aussi possible de réinitialiser l'ensemble des cellules, en allant dans l'onglet 'Exécution' et en exécutant 'Réinitialiser tous les environnements d'exécution...''.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FznAGIGIxmVk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L2 = ... # A compléter"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mDYheXSLwohM",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "-ugSlTx8wohN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(L1)\n",
        "L1[1] = L1[1]+12\n",
        "print(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7nZPFkfwohQ",
        "colab_type": "text"
      },
      "source": [
        "Vous avez dû obtenir en deuxième ligne : [1, **14**, 3.5, '7', -2.4, 'test']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fSnNBY_9wohR",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "Qp72JqhmwohW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1 = [1,14,3.5,'7',-2.4,'test']\n",
        "print('L1 =',L1,'')\n",
        "print('L1[3] est de type :',type(L1[3]))\n",
        "L1[3]=int(L1[3]) # on écrira float(L1[3]) pour le transformer en type float.\n",
        "print(L1)\n",
        "print('Maintenant L1[3] est de type :',type(L1[3]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6tOzmL5awohf",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "kqCP__Pawohg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n = 53\n",
        "print('u_',str(n),' vaut :',len(str(n))/(n*(n+1)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-g5E11Uhwohl",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "vyiUZB47wohn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1.append(14) # ajout de 14 en fin de liste\n",
        "print(L1)\n",
        "L1 = L1+[14] # autre méthode possible...\n",
        "print(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nc9UgHZJwoiC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1.insert(3,54) # insertion de x=54 à la position i=3\n",
        "print(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S1NOZR7fwoiH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1.index(54) # retourne l'index de la première occurence de x=54"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUBNPESHwoiL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1.count(14) # dénombre les x=14 présents dans L1 - essayer avec d'autres valeurs..."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uxRl2ELKwoiP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "del L1[6:] # suppression des termes indexés à partir de 7\n",
        "print(L1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BbDe30MuwoiS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L1.sort() # tri croissant de L1\n",
        "print(L1)\n",
        "L1.sort(reverse = True)\n",
        "print(L1) # tri décroissant"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jIoqlyapwoiW",
        "colab_type": "text"
      },
      "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": {
        "id": "wZl7KB9WwoiZ",
        "colab_type": "text"
      },
      "source": [
        "Voyons maintenant les moyens de faire la **copie** d'une liste - la copie *superficielle* puis la copie *profonde* :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DHaMAuTxwoia",
        "colab_type": "code",
        "colab": {}
      },
      "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)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wy90O6_fwoid",
        "colab_type": "text"
      },
      "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]...  aussi `L[1][0]` a-t-il aussi été modifié.\n",
        "Reprenons :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fx2B5XGiwoif",
        "colab_type": "code",
        "colab": {}
      },
      "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)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HYI4H3vhwoik",
        "colab_type": "text"
      },
      "source": [
        "### 3.3 Création de listes particulières :"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cqU8Jxtmwoil",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "IWyH81t8woin",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(range(10))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-shQTOfwois",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for k in range(10):\n",
        "    print(k**2,end = \" \")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yed2P15awoi3",
        "colab_type": "text"
      },
      "source": [
        "Mais bien d'autres possibilités s'offrent à vous :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XvWItEmFwoi6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(range(2,12))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RHe3_7A4wojG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(range(2,12,2))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nr5dyoJEwojL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(range(7,-5,-1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9vV5CR_SwojP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "[0]*10"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jFZUVT5Rwoja",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "[4,8,'bip']*3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-N3bsvlxwojh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(range(5))*2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ugLRS2RRwojl",
        "colab_type": "text"
      },
      "source": [
        "On peut aussi créer des listes \"en compréhension\" :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JVTUwrRFwojm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L = [k**2 for k in range(11)]\n",
        "print(L)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hUUnYVujwojx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L2 = [k**2 for k in range(11) if k%2 == 0]\n",
        "print(L2) # ne contient que les carrés pairs puisque 'k%2' désigne le reste de la division par 2\n",
        "L3 = [k**2 for k in range(11) if (k > 4) and (k%2 == 0)]\n",
        "print(L3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1CpTOOIwoj3",
        "colab_type": "text"
      },
      "source": [
        "Et même créer des listes de listes, utiles pour constituer des tableaux ou des matrices :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Il9ieWo6woj4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L4 = [[i**2+j for i in range(3)] for j in range(2)]\n",
        "print(L4)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZDfc3YCowoj-",
        "colab_type": "code",
        "colab": {}
      },
      "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])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O-VN1WgpwokQ",
        "colab_type": "text"
      },
      "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",
      "metadata": {
        "id": "x-PBd48fwokS",
        "colab_type": "code",
        "colab": {}
      },
      "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)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pBwB_2kiwoka",
        "colab_type": "text"
      },
      "source": [
        "ou encore, si on souhaite faire le produit scalaire de deux vecteurs $u$ et $v$ :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N-UyLysowokn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "u = [1,0,2]\n",
        "v = [-1,1,3]\n",
        "print(sum(x*y for x,y in zip(u,v)))"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}