04 - Structures de données (Listes et Tuples).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled4.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNJAEomf56R9Aj2AZzGRpQF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MachineLearnia/Python-tutoriel/blob/master/04%20-%20Structures%20de%20donn%C3%A9es%20(Listes%20et%20Tuples).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zZAigZmjo-Eu",
        "colab_type": "text"
      },
      "source": [
        "# 4/30 : Structure de données (Listes et Tuples)\n",
        "\n",
        "Une structure de données est une variable capable de contenir plusieurs valeurs a la fois. Une structure de données peut former une **séquence** si les valeurs qui la composent sont rangées dans un certains ordre. C'est le cas des **listes** et des **tuples**. A l'inverse un **Dictionnaire** ne forme pas une séquence."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYmh0u3Gp2vR",
        "colab_type": "text"
      },
      "source": [
        "## 1. Création de Listes et de Tuples\n",
        "une liste ou un tuple peuvent contenir tout types de valeurs (int, float, bool, string). On dit que ce sont des structures hétérogenes.\n",
        "\n",
        "La différence entre les 2 est qu'une liste est **mutable** alors qu'un Tuple ne l'est pas (on ne peut pas le changer apres qu'il soit crée)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lMrHIDBro9Ul",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Listes\n",
        "liste_1 = [1, 4, 2, 7, 35, 84]\n",
        "villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']\n",
        "nested_list = [liste_1, villes] # une liste peut meme contenir des listes ! On appelle cela une nested list\n",
        "\n",
        "#Tuples\n",
        "tuple_1 = (1, 2, 6, 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6fmme6vsq9mp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9eb5c9e1-ecef-4560-8e22-318e683a3d9d"
      },
      "source": [
        "print(villes)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Paris', 'Berlin', 'Londres', 'Bruxelles']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "if5Og4U5rFJT",
        "colab_type": "text"
      },
      "source": [
        "## 2. Indexing et Slicing\n",
        "Dans une séquence, chaque élément est rangé selon un **index** (le premier index étant l'index 0)\n",
        "\n",
        "Pour acceder a un élément d'une liste ou d'un tuple, on utilise une technique appelée **Indexing**\n",
        "\n",
        "Pour acceder a plusieurs éléments d'une liste ou d'un tuple, on utilie une technique appelée **Slicing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J1EuMMrSq_X2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "a642c0a2-9906-4478-f0e1-3c766f32dbd8"
      },
      "source": [
        "# INDEXING\n",
        "\n",
        "print('séquence complete:', villes)\n",
        "print('index 0:', villes[0])\n",
        "print('index 1:', villes[1])\n",
        "print('dernier index (-1):', villes[-1])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "séquence complete: ['Paris', 'Berlin', 'Londres', 'Bruxelles']\n",
            "index 0: Paris\n",
            "index 1: Berlin\n",
            "dernier index (-1): Bruxelles\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8rmbVqLNsHIy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "39855646-5c98-4c97-cac4-fec5c2b9428d"
      },
      "source": [
        "# SLICING [début (inclus) : fin (exclus) : pas]\n",
        "\n",
        "print('séquence complete:', villes)\n",
        "print('index 0-2:', villes[0:3])\n",
        "print('index 1-2:', villes[1:3])\n",
        "print('ordre inverse:', villes[::-1])"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "séquence complete: ['Paris', 'Berlin', 'Londres', 'Bruxelles']\n",
            "index 0-2: ['Paris', 'Berlin', 'Londres']\n",
            "index 1-2: ['Berlin', 'Londres']\n",
            "ordre inverse: ['Bruxelles', 'Londres', 'Berlin', 'Paris']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9i0rLn2TtUwd",
        "colab_type": "text"
      },
      "source": [
        "## 3. Actions utiles sur les listes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zJbTtPytH3G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "4ef03019-4ace-4717-e729-197d308a2bd8"
      },
      "source": [
        "villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles'] # liste initiale\n",
        "print(villes)\n",
        "\n",
        "villes.append('Dublin') # Rajoute un élément a la fin de la liste\n",
        "print(villes)\n",
        "\n",
        "villes.insert(2, 'Madrid') # Rajoute un élément a l'index indiqué\n",
        "print(villes)\n",
        "\n",
        "villes.extend(['Amsterdam', 'Rome']) # Rajoute une liste a la fin de notre liste\n",
        "print(villes)\n",
        "\n",
        "print('longeur de la liste:', len(villes)) #affiche la longueur de la liste\n",
        "\n",
        "villes.sort(reverse=False) # trie la liste par ordre alphabétique / numérique\n",
        "print(villes)\n",
        "\n",
        "print(villes.count('Paris')) # compte le nombre de fois qu'un élément apparait dans la liste"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Paris', 'Berlin', 'Londres', 'Bruxelles']\n",
            "['Paris', 'Berlin', 'Londres', 'Bruxelles', 'Dublin']\n",
            "['Paris', 'Berlin', 'Madrid', 'Londres', 'Bruxelles', 'Dublin']\n",
            "['Paris', 'Berlin', 'Madrid', 'Londres', 'Bruxelles', 'Dublin', 'Amsterdam', 'Rome']\n",
            "longeur de la liste: 8\n",
            "['Amsterdam', 'Berlin', 'Bruxelles', 'Dublin', 'Londres', 'Madrid', 'Paris', 'Rome']\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUhBRJwqvg1p",
        "colab_type": "text"
      },
      "source": [
        "Les listes et les tuples fonctionnent en harmonies avec les structures de controle **if/else** et **For**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XjHrv7HjuFCE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "117ddbc4-cfa8-4de5-bdc2-6e8417604a5c"
      },
      "source": [
        "if 'Paris' in villes:\n",
        "  print('oui')\n",
        "else:\n",
        "  print('non')"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "oui\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HHSiF8g5vyEh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "34f919cf-1d0e-43cb-9bc4-19281d9d8872"
      },
      "source": [
        "for element in villes:\n",
        "  print(element)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Amsterdam\n",
            "Berlin\n",
            "Bruxelles\n",
            "Dublin\n",
            "Londres\n",
            "Madrid\n",
            "Paris\n",
            "Rome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8o9svv2v88a",
        "colab_type": "text"
      },
      "source": [
        "La fonction **enumerate** est tres utile pour sortir a la fois les éléments d'une liste et leurs **index**. C'est une fonction tres utilisée en datascience"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9t8cMPzv1Ug",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "579039b4-91a6-4f8a-bfcd-e9d2adee574d"
      },
      "source": [
        "for index, element in enumerate(villes):\n",
        "  print(index, element)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 Amsterdam\n",
            "1 Berlin\n",
            "2 Bruxelles\n",
            "3 Dublin\n",
            "4 Londres\n",
            "5 Madrid\n",
            "6 Paris\n",
            "7 Rome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7pQ6Yl_wd-B",
        "colab_type": "text"
      },
      "source": [
        "La fonction **zip** est aussi tres utile pour itérée a travers 2 listes en paralleles. Si une liste est plus courte que l'autre, la boucle for s'arrete a la liste la plus courte"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ej3rTRqawN2i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "48fc7aec-a096-4582-ae47-27eb0973b522"
      },
      "source": [
        "liste_2 = [312, 52, 654, 23, 65, 12, 678]\n",
        "for element_1, element_2 in zip(villes, liste_2):\n",
        "  print(element_1, element_2)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Amsterdam 312\n",
            "Berlin 52\n",
            "Bruxelles 654\n",
            "Dublin 23\n",
            "Londres 65\n",
            "Madrid 12\n",
            "Paris 678\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vvjPq9a8w80t",
        "colab_type": "text"
      },
      "source": [
        "## 4. Exercice et Solution\n",
        "Transformer le code suivant qui donne la **suite de Fibonacci** pour enregistrer les résultats dans une liste et retourner cette liste a la fin de la fonction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XRp6AbXIwyCn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Exercice :\n",
        "def fibonacci(n):\n",
        "    a = 0\n",
        "    b = 1\n",
        "    while b < n:\n",
        "      a, b = b, a+b\n",
        "      print(a)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_r2fVNGrxenQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9022a5b2-1c54-441f-a453-60e709145d4c"
      },
      "source": [
        "# SOLUTION :\n",
        "\n",
        "def fibonacci(n):\n",
        "    a = 0\n",
        "    b = 1\n",
        "    fib = [a] # Création d'une liste fib \n",
        "    while b < n:\n",
        "        a, b = b, a+b\n",
        "        fib.append(a) # ajoute la nouvelle valeur de a a la fin de fib\n",
        "    return fib\n",
        "\n",
        "print(fibonacci(1000))"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DHS-JClnxsDx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}