Les_tableaux.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les tableaux :\n",
    "\n",
    "Un tableau est une suite ordonnée d'éléments. Ces éléments sont séparés par des virgules et entourés par des crochets.\n",
    "\n",
    "En Python, un tableau est de type list.\n",
    "\n",
    "## Exemples :\n",
    "\n",
    "### Un tableau vide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTableau = []\n",
    "monTableau, type(monTableau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un tableau d'entiers :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_entiers = [ 1, 2, 3, 4, 5]\n",
    "tab_entiers, type(tab_entiers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un tableau de chaines de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines = [ \"toto\", \"titi\", \"tata\", \"tutu\", \"tete\"]\n",
    "tab_chaines, type(tab_chaines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un tableau de tuples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_tuples = [(1, 2, 'moi'),(3, 4, 'toi'),(5, 6, 'nous')]\n",
    "tab_tuples, type(tab_tuples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un tableau de tableau :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_tableaux = [[0, 2, 4, 6, 8],[1, 3, 5, 7, 9]]\n",
    "tab_tableaux, type(tab_tableaux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Présentation sous forme de matrice en ligne et colonne :**\n",
    ">\n",
    "> ```python\n",
    "matrice = [[1, 2, 3],\n",
    "           [4, 5, 6],\n",
    "           [7, 8, 9]]\n",
    "```\n",
    "> Pour cibler un élément particulier de la matrice, on utilise la notation avec \"doubles crochets\" : matrice[ligne][colonne] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_tuples = [(1, 2, 'moi'),\n",
    "              (3, 4, 'toi'),\n",
    "              (5, 6, 'nous')]\n",
    "\n",
    "tab_tableaux = [[0, 2, 4, 6, 8],\n",
    "                [1, 3, 5, 7, 9]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture d'un tableau par index :\n",
    "\n",
    "Le premier élément est toujours à l'index `0`, le dernier est toujours à l'index `-1` :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;border-color:#aabcfe;}\n",
    ".tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#aabcfe;color:#669;background-color:#e8edff;}\n",
    ".tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#aabcfe;color:#039;background-color:#b9c9fe;}\n",
    ".tg .tg-htl6{font-size:14px;font-family:\"Comic Sans MS\", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:middle}\n",
    ".tg .tg-yaja{font-size:14px;font-family:\"Comic Sans MS\", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-l3hy{background-color:#D2E4FC;font-size:14px;font-family:\"Comic Sans MS\", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:middle}\n",
    ".tg .tg-adyi{background-color:#D2E4FC;font-size:14px;font-family:\"Comic Sans MS\", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "  <tr>\n",
    "    <th class=\"tg-htl6\">\"toto\"</th>\n",
    "    <th class=\"tg-htl6\">\"titi\"</th>\n",
    "    <th class=\"tg-htl6\">\"tata\"</th>\n",
    "    <th class=\"tg-htl6\">\"tutu\"</th>\n",
    "    <th class=\"tg-htl6\">\"tete\"</th>    \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-yaja\">0</td>\n",
    "    <td class=\"tg-yaja\">1</td>\n",
    "    <td class=\"tg-yaja\">2</td>\n",
    "    <td class=\"tg-yaja\">3</td>\n",
    "    <td class=\"tg-yaja\">4</td>    \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-adyi\">-5</td>\n",
    "    <td class=\"tg-adyi\">-4</td>\n",
    "    <td class=\"tg-adyi\">-3</td>\n",
    "    <td class=\"tg-adyi\">-2</td>\n",
    "    <td class=\"tg-adyi\">-1</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accès à un élément :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_tuples[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"toto\" in tab_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines.index(\"toto\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parcours des éléments d'un tableau :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for element in tab_chaines :\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fontion `len(monTableau)` renvoie la taille d'un tableau, le nombre d'éléments qu'il contient :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(tab_chaines)) :\n",
    "    print(tab_chaines[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(tab_tableaux)) :\n",
    "    for j in range(len(tab_tableaux[i])) :\n",
    "        print(tab_tableaux[i][j])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modification du contenu d'un tableau :\n",
    "\n",
    "Contrairement à un `tuple`, un tableau est mutable, c'est à dire que l'on peut modifer l'un de ses éléments.\n",
    "\n",
    "### Modifier un élément :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines[4]=\"tyty\"\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ajouter/supprimer un élément :\n",
    "- Pour ajouter un élément à une liste on utilise la méthode **``append()``**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines.append(\"toto\")\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remplissage d'un tableau dans une boucle\n",
    "tab_cubes = [] # on déclare un tableau vide\n",
    "for k in range(10):\n",
    "    tab_cubes.append(k**3) # on ajoute le cube de l'indice à chaque tour de boucle\n",
    "tab_cubes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Pour supprimer un élément à une liste on utilise la méthode **``remove()``** ou encore la fonction **`del()`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines.remove(\"toto\")\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines.remove(tab_chaines[-1])\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(tab_chaines[0])\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concaténation :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_chaines = [\"toto\"] + tab_chaines + [\"tete\"]\n",
    "tab_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTableau = [0] * 6\n",
    "monTableau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autre méthodes :\n",
    "\n",
    "> Placer le curseur après le point et appuyer sur la touche `Tab`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTableau."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tableau par compréhension :\n",
    "\n",
    "Il est possible de créer un tableau et de le remplir en une ligne grâce à la compréhension de tableau :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_tab_entier = [n for n in range(1,6)]\n",
    "new_tab_entier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_tab_cubes = [k**3 for k in range(10)]\n",
    "new_tab_cubes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste_de_mots = [ \"Cosinus\", \"Sinus\", \"Tangente\", \"Cotangente\" ]\n",
    "new_tab = [ len(mot) for mot in ma_liste_de_mots]\n",
    "new_tab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_input = [input(\"saisir un entier positif = \") for n in range(4)]\n",
    "tab_decimal = [int(n) for n in tab_input]\n",
    "tab_binaire = [bin(n) for n in tab_decimal]\n",
    "tab_hexadecimal = [hex(n) for n in tab_decimal]\n",
    "tab_input, tab_decimal, tab_binaire, tab_hexadecimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La compréhension de tableau permet de rajouter une condition `if` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_tab_tableaux = [[i for i in range(10) if i % 2 == 0],[j for j in range(10) if j % 2 == 1]]\n",
    "new_tab_tableaux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiples_de_cinq_ou_de_sept_mais_pas_des_deux = [n for n in range(100) if ((n % 5 == 0 or n % 7 == 0) and n % 35 != 0)]\n",
    "multiples_de_cinq_ou_de_sept_mais_pas_des_deux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Une instruction par compréhension se construit de la façon suivante :**\n",
    ">```python\n",
    "[fonction for i in sequence condition]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identité et copie de tableau :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deux tableaux qui sont liés par une relation d'égalité pointent vers la même adresse mémoire.\n",
    "\n",
    "La modification de l'un entraîne la modification de l'autre.\n",
    "\n",
    "Si l'on souhaite mémoriser l'état initial d'un tableau avant sa modification il faut le copier au préalable avec la méthode `copy()`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = [1,2,3]\n",
    "t2 = t1\n",
    "t3 = t1.copy()\n",
    "t1, t2, t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1[0] = 5\n",
    "t1, t2, t3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observation avec Python tutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from metakernel import register_ipython_magics\n",
    "register_ipython_magics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%tutor\n",
    "t1 = [1,2,3]\n",
    "t2 = t1\n",
    "t3 = t1.copy()\n",
    "t1[0] = 5\n",
    "t3[1] = 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 class='fa fa-code' style=\"color: darkorange\"> A programmer vous-même :</h3>\n",
    "\n",
    "\n",
    "#### EXERCICE n°1 :\n",
    "\n",
    "1- Écrire une fonction ``additionne_element(tableau)`` qui retourne la somme des éléments d’un tableau.\n",
    "\n",
    "Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``\n",
    "\n",
    "2- Écrire une fonction ``moyenne_element(tableau)`` qui retourne la moyenne des éléments d’un tableau.\n",
    "\n",
    "Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``\n",
    "\n",
    "#### EXERCICE n°2 :\n",
    "\n",
    "Écrire une fonction ``supprimer_doublons(tableau)`` qui permet de supprimer les doublons d'un tableau.\n",
    "\n",
    "Tester pour ``tableau = [20,41,52,41,20,78,41,63,52,20]``\n",
    "\n",
    "#### EXERCICE n°3 :\n",
    "\n",
    "1- Écrire une fonction ``multiplie_par_2(tableau)`` qui multiplie par 2 chaque élément du tableau\n",
    "\n",
    "Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``\n",
    "\n",
    "2- Écrire une compréhension de tableau qui permet d’effectuer cette tâche.\n",
    "\n",
    "3- Compléter cette instruction pour que le tableau ne contienne que des valeurs supérieures à 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "****\n",
    "## Références aux programmes :\n",
    "\n",
    "<style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
    ".tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}\n",
    ".tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}\n",
    ".tg .tg-cv16{font-weight:bold;background-color:#dae8fc;border-color:inherit;text-align:center}\n",
    ".tg .tg-xldj{border-color:inherit;text-align:left}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "  <tr>\n",
    "    <th class=\"tg-cv16\">Contenus</th>\n",
    "    <th class=\"tg-cv16\">Capacités attendues</th>\n",
    "    <th class=\"tg-cv16\">Commentaires</th>\n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td class=\"tg-xldj\">Tableau indexé,<br> tableau donné en compréhension</td>\n",
    "    <td class=\"tg-xldj\">Lire et modifier les éléments d’un tableau grâce à leurs index.<br> Construire un tableau par compréhension.<br> Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j].<br>Itérer sur les éléments d’un tableau.\n",
    "</td>\n",
    "    <td class=\"tg-xldj\">Seuls les tableaux dont les éléments sont du même type sont présentés.<br> Aucune connaissance des\n",
    "tranches (slices) n’est exigible. <br> L’aspect dynamique des tableaux de Python n’est pas évoqué.<br> Python identifie listes et tableaux. <br>Il n’est pas fait référence aux tableaux de la bibliothèque NumPy.\n",
    "</td>\n",
    "  </tr>\n",
    "  \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pour Aller plus loin :\n",
    "Le type `list` de Python permet de créer des tableaux (des listes de listes) pas obligatoirement homogènes en taille, ni en type :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monTableau= [[1,2,3,4],[\"toto\",\"titi\",\"tata\"], [-3.14, 0.5, 1, 2.35, 6.48]]\n",
    "monTableau[1][0], type(monTableau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La bibliothèque **``numpy``** permet de gérer des tableaux numériques homogènes, des matrices..."
   ]
  }
 ],
 "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.7.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}