2_Collections.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2_Collections.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "iaqayQP0v8VO"
      ],
      "toc_visible": true,
      "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/titsitits/Python_Data_Science/blob/master/2_Collections.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DfQ-d2onvooo",
        "colab_type": "text"
      },
      "source": [
        "Mickaël Tits\n",
        "CETIC\n",
        "mickael.tits@cetic.be"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "BvC5iZXocZu8"
      },
      "source": [
        "# Chapitre 2 - Les collections d'objets Python\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYk7hlzIa-tk",
        "colab_type": "text"
      },
      "source": [
        "Les collections de données sont des **objets** de type dit **conteneur**, qui contiennent d'autres objets, tels que des int, string, d'autres collections de données, ou tout autre type d'objet (tels que ceux vus dans les chapitres suivants).\n",
        "\n",
        "Ces collections permettent de structurer les données, en représentant soit différentes données d'un même type (une liste de prix par exemple), ou les différentes caractéristiques d'un élément (e.g.: l'adresse, la surface, et le prix d'une maison en vente).\n",
        "\n",
        "La représentation des objets sous forme de collection permet de les traiter de manière systématique: appliquer une instruction sur chaque élément, filtrer tous les éléments respectant une conditions, etc.\n",
        "\n",
        "En Python, il existe différents types de collection de données, qui ont chacune leurs spécificités, avantages et inconvénients:\n",
        "\n",
        "* Les **listes** (**`list`**): une séquence ordonnée d'objets modifiable\n",
        "* Les **tuples** (**`tuple`**): une séquence ordonnée d'objets immuable (voir ci-dessous)\n",
        "* Les **dictionnaires** (**`dict`**): un ensemble de paires clé-valeur\n",
        "* Le **string** (**`str`**) peut être vu comme une séquence ordonnée de caractères\n",
        "* Le **set** (**`set`**): un ensemble d'objets distincts (pas abordés dans ce cours. Pour plus d'informations, voir [ici](https://docs.python.org/3/tutorial/datastructures.html#sets) ou [ici](https://www.programiz.com/python-programming/set#methods))\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "P0kqmbEodMPS"
      },
      "source": [
        "# Les listes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXfBTS3wbBy6",
        "colab_type": "text"
      },
      "source": [
        "* Séquence (collection ordonnée) de données"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fguPPOnVx-jP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mystring = \"1234\"\n",
        "mystring[2] = \"0\"\n",
        "mystring"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "j7uHUigydMPT",
        "colab": {}
      },
      "source": [
        "#Pour déclarer une liste d'éléments, on utilise des crochets []\n",
        "my_list = [1, 3, 5, 7]\n",
        "my_list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3aRsaLrZdMPW",
        "colab": {}
      },
      "source": [
        "# Une liste peut contenir différents types de données\n",
        "my_list2 = [3.14, 42, my_list, True, 'Namur']\n",
        "my_list2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "EbTB1_PDdMPY",
        "colab": {}
      },
      "source": [
        "#La fonction len() permet de connaître la longueur d'une liste\n",
        "len(my_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "alcUwW-qdMPa"
      },
      "source": [
        "### Accès aux données d'une liste\n",
        "* L'opérateur [x] permet d'accéder aux éléments d'une liste\n",
        "* Attention: l'indexation commence à 0\n",
        "* Une erreur est renvoyée si l'indice est invalide\n",
        "* Un indice négatif démarre de la fin de la liste\n",
        "* Le symbole \":\" permet d'accéder à plusieurs éléments consécutifs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "_KOIt-wGdMPa",
        "colab": {}
      },
      "source": [
        "my_list[0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "h8pFOynCdMPc",
        "colab": {}
      },
      "source": [
        "my_list[2]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "sNkopBHkdMPd",
        "colab": {}
      },
      "source": [
        "#Une erreur est obtenue si l'indice est invalide\n",
        "#my_list[4]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "UcYHMIi-dMPf",
        "colab": {}
      },
      "source": [
        "#Un indice négatif part de la fin d'une liste\n",
        "my_list[-1], my_list[-2]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "OmfDUIgZdMPg",
        "colab": {}
      },
      "source": [
        "#On peut accéder à plusieurs éléments d'une liste en utilisant un colon (:)\n",
        "print(my_list[1:3]) #permet d'accéder aux éléments entre les indices 1 et 3 (3 exclu)\n",
        "print(my_list[1:]) #permet d'accéder aux élements à partir de l'indice 1 (jusqu'au dernier)\n",
        "print(my_list[:2]) #permet d'accéder aux éléments du premier jusqu'à l'indice 2 (2 exclu)\n",
        "print(my_list[:]) #permet d'accéder à tous les éléments\n",
        "print(my_list[1:4:2]) #permet d'accéder aux éléments de 1 à 4 (4 exclu) par pas de 2\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "rod9JCbMdMPi"
      },
      "source": [
        "### Manipulation de listes\n",
        "* Addition (+) = concaténation: [1,2] + [3,4] = [1,2,3,4]\n",
        "* Multiplication (\\*) = multiple concaténation: [1,2]\\*2 = [1,2,1,2]\n",
        "* Opération élémentaire => compréhension de liste: [i*4 for i in my_list]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "C4QHuIrudMPi",
        "colab": {}
      },
      "source": [
        "#Additionner des listes résulte en une concaténation\n",
        "my_list+[4, 5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ZYKKmLuGdMPk",
        "colab": {}
      },
      "source": [
        "#Naturellement, la multiplication résulte en une multiple concaténation\n",
        "my_list*2, [0]*10"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5zPlIwfddMPl",
        "colab": {}
      },
      "source": [
        "#On peut modifier les éléments d'une liste (on dit que c'est un objet mutable)\n",
        "my_list[0] = 42\n",
        "my_list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gnr4rZgkdMPn",
        "colab": {}
      },
      "source": [
        "#On ne peut pas additionner un entier à une liste\n",
        "#my_list + 4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dZKQ4anxdMPo",
        "colab": {}
      },
      "source": [
        "#Pour réaliser une opération sur chaque élément d'une liste, on peut utiliser une boucle for\n",
        "\n",
        "#%%timeit\n",
        "\n",
        "my_list_plus_4 = [0]*len(my_list)\n",
        "\n",
        "for i in range(len(my_list)):\n",
        "  my_list_plus_4[i] = my_list[i] + 4\n",
        "\n",
        "my_list_plus_4\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "lukH-ujldMPq",
        "colab": {}
      },
      "source": [
        "#Ou\n",
        "\n",
        "#%%timeit\n",
        "\n",
        "my_list_plus_4 = [] #liste vide\n",
        "\n",
        "for item in my_list:\n",
        "  my_list_plus_4.append(item + 4) #ajouter un élément à la nouvelle liste\n",
        "  \n",
        "my_list_plus_4  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dhcFEDMvxd0Z",
        "colab_type": "text"
      },
      "source": [
        "## Fonctions de base sur les listes\n",
        "\n",
        "Pour chaque type de collection d'objets, différentes fonctions de base permettent de réaliser différents type d'opérations, tels que:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QaYSaUrfx0xn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#permet de connaître la longueur d'une list\n",
        "l = len(my_list)\n",
        "#Les opérations mathématiques ne fonctionnent que sur les listes\n",
        "#dont tous les éléments sont numériques\n",
        "num_list = [1,2,3, True, 4.2]\n",
        "s = sum(num_list)\n",
        "M = max(num_list)\n",
        "m = min(num_list)\n",
        "\n",
        "a = any([False,False,True]) #output: True\n",
        "A = all([False,False,True]) #output: False\n",
        "print(l, s, M, m, a, A)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9NGzHVBJnORI",
        "colab_type": "text"
      },
      "source": [
        "## Compréhension de listes\n",
        "Instruction plus compacte, et plus rapide (et souvent plus lisible) pour réaliser une opération sur chaque élément dans une liste.\n",
        "\n",
        "Syntaxe: \n",
        "\n",
        "`new_list = [instruction for item in list if condition]`\n",
        "\n",
        "Code équivalent sans compréhension de liste:\n",
        "\n",
        "\n",
        "```\n",
        "new_list = []\n",
        "for item in list:\n",
        "  if condition:\n",
        "    output = instruction\n",
        "    new_list.append(output)\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "bhiq2Ge2dMPr",
        "colab": {}
      },
      "source": [
        "#Pour additionner un scalaire à chaque éléments d'une list, on peut aussi utiliser une \"list-comprehension\": plus compacte, et plus rapide\n",
        "\n",
        "#%%timeit\n",
        "\n",
        "my_list_plus_4 = [i + 4 for i in my_list]\n",
        "my_list_plus_4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lUuWN0alo9Fv",
        "colab_type": "text"
      },
      "source": [
        "On peut représenter une matrice par une liste de listes. On peut réaliser une opération entre deux liste avec une double compréhension de liste.\n",
        "\n",
        "**Remarque**: En pratique, pour les opérations mathématiques on utilise généralement des librairies spécialisées, telles que **`numpy`** (voir Chapitre 5)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "za6XJnCWirv5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_list1 = [1,2,3,4]\n",
        "my_list2 = [5,6,7,8]\n",
        "\n",
        "#my_list1'*my_list2:\n",
        "matprod = [ [a*b for b in my_list2] for a in my_list1]\n",
        "matprod"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Mv-JRjYFdMPu",
        "colab": {}
      },
      "source": [
        "my_list = [-1, 2, 3, -7, 5, -4, 2, 8, -56, 9, 5.3, -4.5]\n",
        "\n",
        "#Remplacer les nombres négatifs par 0 ?\n",
        "zero_list = []\n",
        "for item in my_list:\n",
        "  if item < 0:\n",
        "    zero_list.append(0)\n",
        "  else:\n",
        "    zero_list.append(item)\n",
        "\n",
        "print('négatifs remplacés par 0:', zero_list)\n",
        "\n",
        "#Ou\n",
        "zero_list = [0 if item < 0 else item for item in my_list]\n",
        "\n",
        "print('négatifs remplacés par 0, bis:', zero_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pvouVh1JdMPw",
        "colab": {}
      },
      "source": [
        "#Eliminer les nombres négatifs d'une liste ?\n",
        "my_list = [-1, 2, 3, -7, 5, -4, 2, 8, -56, 9, 5.3, -4.5]\n",
        "positive_list = [item for item in my_list if item >= 0]\n",
        "print('négatifs éliminés:', positive_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2cr6Y6LzkcYF",
        "colab_type": "text"
      },
      "source": [
        "## Exercice: filtrer une liste de prix\n",
        "Parmi une liste de prix, ne garder que ceux entre 200.000 et 300.000."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "enOi67CUqL33",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prices = [50000, 1000, 500000, 200000, 300000, 400000, 260000, 270000]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N_70SZ5SwDB6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lJGRQGAPNAYQ",
        "colab_type": "text"
      },
      "source": [
        "Solutions des exercices [ici](https://github.com/titsitits/Python_Data_Science/blob/master/Exercise_Solutions.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wTBznGUrdMPx"
      },
      "source": [
        "# Les tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1np555hZbIAa",
        "colab_type": "text"
      },
      "source": [
        "* Les tuples sont des listes immuables.\n",
        "* A quoi ça sert ?\n",
        "  * Traitement plus rapide dans certains contextes\n",
        "  * Moins de risque de confusion due à de multiple références d'un objet mutable (voir Chapitre 3)\n",
        "  * Certains traitements nécessitent des objets immuables et ne peuvent donc pas être utilisés avec des listes. E.g.: les clés d'un dictionnaires (voir Section suivante)\n",
        "\n",
        "**Remarque**: on utilise en général des tuples pour représenter une structure de données: \n",
        "\n",
        "E.g.: `a_house = (\"Rue de Fer 25, Namur\", \"villa\", 2000000, 4, \"immoweb\")`\n",
        "\n",
        "Avec des types généralement différents. Ce type de représentation a peu d'intérêt d'être mutable.  Il représente les caractéristiques d'un bien immobilier dans cet exemple (addresse, type, prix, nombre de chambre, source).\n",
        "A l'inverse, on utilise généralement une liste pour représenter une collection d'objets homogènes (bien que ça accepte des types hétérogènes). \n",
        "\n",
        "E.g.: `house_prices = [200000, 350000, 170000, 270000]`\n",
        "\n",
        "L'utilisation d'une liste permet de facilement ajouter/supprimer des éléments (généralement du même type, e.g. de nouveaux prix), et de réaliser rapidement des instructions sur chaque élément grâce aux compréhensions de liste."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DpGw57sKdMPy",
        "colab": {}
      },
      "source": [
        "#L'utilisation de parenthèses permet de déclarer un tuple\n",
        "my_tuple = (\"Rue de Fer 25, Namur\", \"villa\", 2000000, 4, \"immoweb\")\n",
        "my_tuple"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a3cE0iEobx8I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_set = {2,1,1,2,1,3,1}\n",
        "my_set.add(4)\n",
        "my_set"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "XEZEZO0ldMPz",
        "colab": {}
      },
      "source": [
        "# Les parenthèses sont conventionnelles mais ne sont cependant pas nécessaires pour déclarer un tuple\n",
        "my_tuple = \"Rue de Fer 25, Namur\", \"villa\", 2000000, 4, \"immoweb\"\n",
        "my_tuple"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kfHScQuRdMP1",
        "colab": {}
      },
      "source": [
        "my_tuple[0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "L-9ZVBPFdMP4",
        "colab": {}
      },
      "source": [
        "#On ne peut pas modifier les éléments d'un tuple, on dit que c'est un \"objet immuable\" (immutable en anglais). La ligne suivante donne donc une erreur\n",
        "my_tuple[2] = 300000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "CMB9TWuedMP6",
        "colab": {}
      },
      "source": [
        "my_list = [-1, 2, 3, -7, 5, -4, 2, 8, -56, 9, 5.3, -4.5]\n",
        "my_tuple = tuple(my_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2zgmYLaSdMP8",
        "colab": {}
      },
      "source": [
        "%timeit my_list = [-1, 2, 3, -7, 5, -4, 2, 8, -56, 9, 5.3, -4.5]\n",
        "%timeit my_tuple = (-1, 2, 3, -7, 5, -4, 2, 8, -56, 9, 5.3, -4.5)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kZkX_xix6ZbT",
        "colab_type": "text"
      },
      "source": [
        "**Remarque**:\n",
        "\n",
        "Les commandes commençant pas % ou %% sont des \"commandes magiques\" propres aux Notebooks, et ne fonctionnent pas dans un script python classique. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AycsAu2eMpUI",
        "colab_type": "text"
      },
      "source": [
        "# Les dictionnaires\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQh0MoRvbLf2",
        "colab_type": "text"
      },
      "source": [
        "Les dictionnaires sont des collection de données de type paire clé-valeur.\n",
        "On utilise des accolades {} pour déclarer un dictionnaire.\n",
        "Les dictionnaires sont des objets mutables, ce qui veut dire qu'on peut ajouter des clés et des valeurs après déclaration.\n",
        "Les dictionnaires permettent notamment de manipuler un ensemble de données tabulaires.\n",
        "\n",
        "**Remarque:** Nous verrons plus loin qu'ils existe une représentation plus pratique de données tabulaires: le DataFrame.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZQJAw91z4j4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "house1 = {\"address\":\"Rue de Fer 25, 5000 Namur\", \"website\":\"immoweb\", \"price\": 400000, \"surface\":150}\n",
        "\n",
        "house2 = {\"address\":\"Rue de Bruxelles 42, 5000 Namur\", \"website\":\"immoweb\", \"price\": 350000, \"surface\":200}\n",
        "\n",
        "house3 = {\"address\":\"Porte de Namur 25, Bruxelles\", \"website\":\"immovlan\", \"price\": 400000, \"surface\":100}\n",
        "\n",
        "#On peut modifier une valeur\n",
        "house1[\"surface\"] = 170\n",
        "\n",
        "#On peut aussi ajouter une clé\n",
        "house1[\"rooms\"] = 4\n",
        "\n",
        "#On peut itérer sur les clés d'un dictionnaire\n",
        "for key in house1:\n",
        "  print(key, ' - ', house1[key])\n",
        "  \n",
        "#On peut utiliser des compréhension de dictionnaire (ce qui crée un nouveau dictionnaire)\n",
        "house1_string = {key:str(house1[key]) for key in house1}\n",
        "print(\"Valeurs du dictionnaire converties en strings:\", house1_string)\n",
        "\n",
        "#On peut aussi utiliser des compréhensions de liste (Remarque: on peut utiliser des compréhension de liste sur tout objet itérable, c'est-à-dire utilisable avec l'instruction \"for\")\n",
        "is_string = [type(house1[key]) is str for key in house1]\n",
        "print(\"is_string:\", is_string)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LPetWxyyMskg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Dictionnaire de dictionnaires\n",
        "house_dataset = {1:house1,2:house2,3:house3}\n",
        "\n",
        "\n",
        "# => Facile d'extraire et ajouter une maison:\n",
        "my_house = house_dataset[2]\n",
        "house_dataset[4] = {\"address\":\"Rue de Fer 26, Namur\", \"website\":\"immovlan\", \"price\": 370000, \"surface\":170}\n",
        "\n",
        "\n",
        "# Facile de filtrer les maisons:\n",
        "big_houses = {k:house_dataset[k] for k in house_dataset if house_dataset[k][\"surface\"] > 150}\n",
        "print(\"Grandes maisons:\", big_houses)\n",
        "\n",
        "\n",
        "# Moins facile d'extraire ou ajouter une caractéristique pour toutes les maisons: on doit modifier itérativement chaque élément (maison)!\n",
        "rooms = [4,3,4,2]\n",
        "keys = list(house_dataset.keys())\n",
        "for i in range(4):\n",
        "  house_dataset[keys[i]][\"rooms\"] = rooms[i]\n",
        "\n",
        "print(house_dataset)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8nH1fRuF03Pn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Dictionnaire de listes ?\n",
        "#Remarque: on peut écrire la déclaration d'une collection d'objet (list [], tuple () ou dict{}) sur plusieurs lignes.\n",
        "house_dataset2 = {\"address\":[\"Rue de Fer 25, 5000 Namur\", \"Rue de Bruxelles 42, 5000 Namur\", \"Porte de Namur 25, Bruxelles\"],\n",
        "          \"website\":[\"immoweb\",\"immoweb\",\"immovlan\"],\n",
        "           \"price\": [400000, 350000, 400000],\n",
        "           \"surface\":[150, 200, 100]}\n",
        "\n",
        "\n",
        "# Plus facile d'extaire et ajouter une caractéristique:\n",
        "prices = house_dataset2[\"price\"]\n",
        "house_dataset2[\"rooms\"] = [4,3,4]\n",
        "\n",
        "\n",
        "#Facile de filtrer des caractéristiques:\n",
        "house_numbers = {k:house_dataset2[k] for k in house_dataset2 if type(house_dataset2[k][0]) is int}\n",
        "print(\"Variables numériques:\", house_numbers)\n",
        "\n",
        "\n",
        "# Mais moins facile d'extraire ou ajouter une maison: on doit modifier itérativement chaque élément (liste)!\n",
        "house4 = (\"Rue de Fer 26, Namur\", \"immovlan\", 370000, 170, 2)\n",
        "keys = list(house_dataset2.keys())\n",
        "for i in range(5):\n",
        "  house_dataset2[keys[i]].append(house4[i])\n",
        "\n",
        "print(house_dataset2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zs4LBR5T1yOb",
        "colab_type": "text"
      },
      "source": [
        "**Remarque:**\n",
        "\n",
        "On verra plus tard qu'il existe une représentation plus pratique des données (le DataFrame), qu'on peut utiliser avec des librairies spécialisées."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "YSsjbGuactyF"
      },
      "source": [
        "# Les strings sont des collections de données du même type"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5KoHyMI2bOn5",
        "colab_type": "text"
      },
      "source": [
        "* le string est une séquence (une collection ordonnée) de caractères\n",
        "* il existe de nombreuses méthodes spécifiques aux string"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2-dmeXrYctyD",
        "colab": {}
      },
      "source": [
        "address = \"Rue de Bruxelles\"\n",
        "\n",
        "print(\"Premier élément:\\n\", address[0])\n",
        "\n",
        "#On peut convertir un string en une autre collection simple (e.g., une liste)\n",
        "print(\"Converti en liste:\\n\", list(address))\n",
        "\n",
        "print(\"Converti en minuscules:\\n\", address.lower() )\n",
        "\n",
        "print(\"Split des mots (i.e. splitter les chaînes entre les whitespaces (' ') ):\\n\", address.split(' ') )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "gybv34UucZhL"
      },
      "source": [
        "# Un opérateur spécifique aux collections: \"in\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJ969OlabSI5",
        "colab_type": "text"
      },
      "source": [
        "* **`for i in [0,1,2,3]:`** itération sur chaque élément de la collection\n",
        "* **`if \"n\" in [\"n\",\"a\",\"m\",\"u\",\"r\"]:`** permet de vérifier la condition qu'un élément soit dans une collection\n",
        "* ça fonctionne aussi pour les strings: **`\"n\" in \"namur\"`** => **`True`**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MtMvGFkwctyB",
        "colab": {}
      },
      "source": [
        "address_list = ['Rue de la Loi, Bruxelles','Rue de Bruxelles 61, Namur',\n",
        "                'Rue de Fer 42, Namur', 'Chaussée de Bruxelles',\n",
        "                'Gauffre de Bruxelles', 'Grand Place, Bruxelles']\n",
        "\n",
        "brux = []\n",
        "\n",
        "for address in address_list:\n",
        "  if 'Bruxelles' in address:\n",
        "    brux.append(address)\n",
        "\n",
        "print(brux)\n",
        "#Ou\n",
        "brux = [address for address in address_list if 'Bruxelles' in address]\n",
        "\n",
        "print(brux)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "id59pbm2rLRr",
        "colab_type": "text"
      },
      "source": [
        "# Récapitulatif de syntaxe\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tPdut8FexLrw",
        "colab_type": "text"
      },
      "source": [
        "## Quand utiliser (), [] et {}\n",
        "\n",
        "Pour assigner une collection d'objet, on utilise `[]` pour une `list`, `()` pour un `tuple`, `{}` pour un `dict`.\n",
        "Pour accéder aux éléments d'une collection, on utilise toujours des crochets [i]. E.g.: `my_list[i], my_tuple[i], my_dict[i]`\n",
        "Pour appeler une function ou une méthode, on utilise des parenthèses. E.g. print(my_list), ou my_list.append(42)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EnPczaoJUMPV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_list = ['a','b','c']\n",
        "my_tuple = (1,2,3)\n",
        "my_dict = {'a':1, 'b':2, 'c':3}\n",
        "\n",
        "my_list.append('d')\n",
        "print(my_list[3], my_tuple[0], my_dict['c'])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "443EvAluxQVq",
        "colab_type": "text"
      },
      "source": [
        "## Nouveaux mots-clés et types de données"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s6qg3h_RxOaV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list\n",
        "dict\n",
        "tuple\n",
        "set\n",
        "\n",
        "len\n",
        "sum\n",
        "max\n",
        "min\n",
        "any\n",
        "all\n",
        "\n",
        "in\n",
        "\n",
        "#list comprehension syntax:\n",
        "[instruction for item in list if condition]\n",
        "\n",
        "#dictionary comprehension syntax\n",
        "{key_instruction:value_instruction for key in dict if condition}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Czz3CM7trM1f",
        "colab_type": "text"
      },
      "source": [
        "Vous êtes maintenant capables de manipuler des collections d'objets, vous pouvez passer au [Chapitre 3: Concepts avancés de programmation: exceptions, fonctions, objets](https://colab.research.google.com/github/titsitits/UNamur_Python_Analytics/blob/master/3_Advanced_Python.ipynb)"
      ]
    }
  ]
}