{ "cells": [ { "cell_type": "markdown", "metadata": { "nbsphinx": "hidden" }, "source": [ "[prev: *type()* et *help()* : introspection](introspection.ipynb) | [home](../index.ipynb) | [next: Structure de contrôle](controle-flux.ipynb)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Les conteneurs de base\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il existe 3 types de conteneurs de base très utilisés en Python\n", "\n", "- `list` : tableau dynamique\n", "- `tuple` : tableau statique\n", "- `dict` : tableau associatif\n", "\n", "\n", "\n", "Ils partagent certaines opérations communes\n", "\n", "- connaître la taille du conteneur\n", "```\n", "taille = len(conteneur) # 'taille' est un int\n", "```\n", "\n", "- tester la présence d'un objet dans le conteneur\n", "```\n", "is_here = obj in conteneur # 'is_here' est un bool\n", "```\n", "\n", "- accéder à un élément du conteneur\n", "```\n", "elem_at_index = conteneur[index] # 'elem_at_index' peut avoir n'importe quel type\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tableau dynamique : `list`" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# '[]' pour créer littéralement une liste\n", "ma_liste = [42, 'bonjour', 3.14]" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(ma_liste)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[42, 'bonjour', 3.14]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ma_liste" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# la liste vide\n", "vide = []" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(vide)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vide" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# taille d'une liste\n", "len(ma_liste)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'un objet\n", "42 in ma_liste" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'un objet\n", "'au revoir' in ma_liste" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "42\n", "bonjour\n", "3.14\n" ] } ], "source": [ "# accès aux éléments -> indexation par des entiers\n", "\n", "# Python compte à partir de 0 !\n", "\n", "print(ma_liste[0])\n", "print(ma_liste[1])\n", "print(ma_liste[2])\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "IndexError", "evalue": "list index out of range", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[11], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# attention à ne pas dépasser\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mma_liste\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m]\u001b[49m\n", "\u001b[1;31mIndexError\u001b[0m: list index out of range" ] } ], "source": [ "# attention à ne pas dépasser\n", "\n", "ma_liste[12]" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[42, 'bonjour', 3.14]\n" ] }, { "data": { "text/plain": [ "[42, 'au revoir', 3.14]" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# on peut modifier le contenu d'un tableau dynamique\n", "\n", "print(ma_liste)\n", "\n", "ma_liste[1] = 'au revoir'\n", "\n", "ma_liste" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 'un', 'deux']\n", "[1, 2, 3, 1, 2, 3]\n", "['un', 'deux', 'un', 'deux', 'un', 'deux']\n" ] } ], "source": [ "# concatenation de listes\n", "\n", "# '+' et '*' marchent comme pour str\n", "\n", "a = [1, 2, 3]\n", "b = ['un', 'deux']\n", "\n", "print(a + b)\n", "print(a * 2)\n", "print(3 * b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tableau statique : `tuple`" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# '()' pour créer littéralement un tuple\n", "mon_tuple = (42, 'bonjour', 3.14)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tuple" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(mon_tuple)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(42, 'bonjour', 3.14)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mon_tuple" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# le tuple vide\n", "vide = ()" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tuple" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(vide)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "()" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vide" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# taille d'un tuple\n", "len(mon_tuple)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'un objet\n", "42 in mon_tuple" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'un objet\n", "'au revoir' in mon_tuple" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "42\n", "bonjour\n", "3.14\n" ] } ], "source": [ "# accès aux éléments -> indexation par des entiers\n", "\n", "# Python compte à partir de 0 !\n", "\n", "print(mon_tuple[0])\n", "print(mon_tuple[1])\n", "print(mon_tuple[2])\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "IndexError", "evalue": "tuple index out of range", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[24], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# attention à ne pas dépasser\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmon_tuple\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m]\u001b[49m\n", "\u001b[1;31mIndexError\u001b[0m: tuple index out of range" ] } ], "source": [ "# attention à ne pas dépasser\n", "mon_tuple[12]" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[25], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# on NE PEUT PAS modifier le contenu d'un tableau statique\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmon_tuple\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mau revoir\u001b[39m\u001b[38;5;124m'\u001b[39m\n", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "# on NE PEUT PAS modifier le contenu d'un tableau statique\n", "mon_tuple[1] = 'au revoir'" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 2, 3, 'un', 'deux')\n", "(1, 2, 3, 1, 2, 3)\n", "('un', 'deux', 'un', 'deux', 'un', 'deux')\n" ] } ], "source": [ "# concatenation de tuples avec '+' et '*'\n", "\n", "a = (1, 2, 3)\n", "b = ('un', 'deux')\n", "\n", "print(a + b)\n", "print(a * 2)\n", "print(3 * b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Quelques subtilités" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "qu'est-ce que 'a' ?\n", "\n", "12\n", "\n", "qu'est-ce que 'b' ?\n", "\n", "(42, 'bonjour', 3.14)\n" ] } ], "source": [ "# '()' pour créer littéralement un tuple ...\n", "# ... enfin, pas tout à fait\n", "\n", "a = (12)\n", "\n", "print(\"qu'est-ce que 'a' ?\")\n", "print(type(a))\n", "print(a)\n", "print()\n", "\n", "b = 42, 'bonjour', 3.14\n", "\n", "print(\"qu'est-ce que 'b' ?\")\n", "print(type(b))\n", "print(b)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "(1,)\n" ] } ], "source": [ "# le 1-tuple\n", "\n", "tuple_de_taille_1 = (1,) # notez la virgule\n", "print(type(tuple_de_taille_1))\n", "print(tuple_de_taille_1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tableau associatif : `dict`" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "# '{clef: valeur}' pour créer littéralement un dict ...\n", "mon_dict = {'un': 42, 2: 'bonjour', 'trois': 3.14}" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dict" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(mon_dict)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'un': 42, 2: 'bonjour', 'trois': 3.14}" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mon_dict" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# le dict vide\n", "vide = {}" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dict" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(vide)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{}" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vide" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# taille d'un dict\n", "len(mon_dict)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'une clef\n", "'un' in mon_dict" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'une clef\n", "2 in mon_dict" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'une clef\n", "42 in mon_dict" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tester la présence d'une clef\n", "'bonjour' in mon_dict" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# si on tient vraiment à chercher dans les valeurs (et non les clefs)\n", "'bonjour' in mon_dict.values()" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "42\n", "bonjour\n", "3.14\n" ] } ], "source": [ "# accès aux éléments -> indexation par des clefs\n", "print(mon_dict['un'])\n", "print(mon_dict[2])\n", "print(mon_dict['trois'])" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "KeyError", "evalue": "'toto'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[42], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# attention à l'absence de clef\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmon_dict\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtoto\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n", "\u001b[1;31mKeyError\u001b[0m: 'toto'" ] } ], "source": [ "# attention à l'absence de clef\n", "mon_dict['toto']" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'un': 42, 2: 'bonjour', 'trois': 3.14}\n" ] }, { "data": { "text/plain": [ "{'un': 42, 2: 'bonjour', 'trois': 2.71828}" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# on peut modifier le contenu d'un tableau dynamique\n", "# quand une clef existe déjà :\n", "print(mon_dict)\n", "mon_dict['trois'] = 2.71828\n", "mon_dict" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'un': 42, 2: 'bonjour', 'trois': 2.71828}\n" ] }, { "data": { "text/plain": [ "{'un': 42, 2: 'bonjour', 'trois': 2.71828, 'quatre': 'nouvelle case'}" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# on peut modifier le contenu d'un tableau dynamique\n", "# avec une nouvelle clef :\n", "print(mon_dict)\n", "mon_dict['quatre'] = \"nouvelle case\"\n", "mon_dict" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "/!\\\\ l'instruction `mon_dict[clef] = valeur` marchera toujours\\*, la taille du dictionnaire *peut* augmenter cela la situation. \n", "(\\*) *presque* toujours, cf exercice" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'un': 1, 'deux': 2, 'trois': 3}" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# concatenation de dict\n", "\n", "a = {'un': 1, 'deux': 2}\n", "b = {'trois': 3}\n", "\n", "a | b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Une chaîne de caractères est un tableau statique" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On retrouve `len()`, `in`, et l'indexation" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [], "source": [ "mot = 'python'" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(mot)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'y' in mot" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "p y t\n", "h o n\n" ] } ], "source": [ "print(mot[0], mot[1], mot[2])\n", "print(mot[3], mot[4], mot[5])" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[50], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# comme tuple, c'est un tableau statique\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmot\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mP\u001b[39m\u001b[38;5;124m'\u001b[39m\n", "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "# comme tuple, c'est un tableau statique\n", "mot[0] = 'P'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conversion en booléen\n", "\n", "Les objets de type `list`, `tuple`, `dict`, ainsi que tous les autres types de conteneurs, se convertissent en booléen:\n", "```\n", " Faux si conteneur vide, Vrai sinon\n", "```" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[] False\n", "[1, 2, 3] True\n" ] } ], "source": [ "# list\n", "vide = []\n", "pas_vide = [1, 2, 3]\n", "\n", "print(vide, bool(vide))\n", "print(pas_vide, bool(pas_vide))" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "() False\n", "(1, 2, 3) True\n" ] } ], "source": [ "# tuple\n", "vide = ()\n", "pas_vide = (1, 2, 3)\n", "\n", "print(vide, bool(vide))\n", "print(pas_vide, bool(pas_vide))" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{} False\n", "{1: 'un', 2: 'deux', 3: 'trois'} True\n" ] } ], "source": [ "# dict\n", "vide = {}\n", "pas_vide = {1: 'un', 2: 'deux', 3: 'trois'}\n", "\n", "print(vide, bool(vide))\n", "print(pas_vide, bool(pas_vide))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conversion entre conteneurs" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "ma_liste = [1, 2, 3]\n", "mon_tuple = (10, 20, 30)\n", "mon_dict = {'a': 100, 'b': 200, 'c': 300}" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2, 3)" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# list -> tuple\n", "tuple(ma_liste)" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[10, 20, 30]" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# tuple -> list\n", "list(mon_tuple)" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['a', 'b', 'c']" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# dict -> list\n", "list(mon_dict)" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a': 100, 'b': 200, 'c': 300}" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# list -> dict\n", "clef_valeur = [['a', 100], ['b', 200], ['c', 300]]\n", "dict(clef_valeur)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercice" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Construire des dictionnaires utilisant des clefs de différents types.\n", "\n", "Quels types ne sont pas autorisés ?\n", "\n", "- [Vecteur de 0](../exercises/exercises.ipynb#Exercice-4-:-liste-de-zéros)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.12" } }, "nbformat": 4, "nbformat_minor": 4 }