{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8d34c50b-45bd-449a-9508-1e60bf93dca6",
   "metadata": {},
   "source": [
    "# Les dictionnaires"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fe7d4a7-1a39-4262-b0b1-e74b1f97fa4d",
   "metadata": {},
   "source": [
    "Un dictionnaire est une collection de paires *clé : valeur*. Les clés sont des chaînes caractères ou des entiers.\n",
    "Contrairement aux listes, il n'y a aucune notion d'ordre dans un dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9e231f21-0605-4563-80f5-da38f55f2377",
   "metadata": {},
   "outputs": [],
   "source": [
    "dico1 = {'France':'Paris','Allemagne':'Berlin','Espagne':'Madrid'} # crée un dictionnaire avec les clés 'France', 'Allemagne' et 'Espagne'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "97c47e5e-9ee7-4537-af2f-57699bad3cc3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Paris'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dico1['France'] # affiche la valeur de la clé 'France'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "28c27f17-27b4-45bc-85bf-6fb509d5084c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berlin'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dico1['Allemagne']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3390fca2-0bc6-46c4-a7fe-cce4b3089b82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dico1) # affiche la longueur du dictionnaire, c'est-à-dire le nombre de clés"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "250dfda6-80c9-45ab-a376-5312d554b4a8",
   "metadata": {},
   "source": [
    "On crée un dictionnaire vide $D$ par la commande:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "01775948-501d-4285-8e4f-02843c85dd1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "dico2=dict() # ou bien D={}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e1fe470-7bb2-47ab-a0ed-e22f2cab24cf",
   "metadata": {},
   "source": [
    "Pour ajouter un élément à un dictionnaire, on donne la clé et la valeur par une simple affectation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e70b288-cd0f-4f53-be1f-93c946b296b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'un': 'one', 'deux': 'two'}\n"
     ]
    }
   ],
   "source": [
    "dico2['un']='one'\n",
    "dico2['deux']='two'\n",
    "print(dico2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a90abbd-664f-4707-8015-767fc4f73041",
   "metadata": {},
   "source": [
    "On supprime un élément avec l'instruction *del*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b5c75784-6e69-4d31-b939-13ba6741c950",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'un': 'one'}\n"
     ]
    }
   ],
   "source": [
    "del(dico2['deux'])\n",
    "print(dico2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "088ab315-88fa-4165-bb84-35472bcc9f88",
   "metadata": {},
   "source": [
    "Quelques méthodes pour travailler avec des dictionnaires~:\n",
    "\n",
    "--- *clear()* : supprime tous les éléments.\n",
    "\n",
    "--- *values()* : renvoie une séquence des valeurs.\n",
    "\n",
    "--- *keys()* : renvoie une séquence des clés.\n",
    "\n",
    "--- *items()* : renvoie une séquence de tuples sour la forme \\lstinline!(clé,valeur)!\n",
    "\n",
    "---  *pop(clé)* : supprime l'élément de la clé en argument et renvoie sa valeur.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c9a900a2-6e1e-4f25-a046-915bb7b59c4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dico={'a':1,'b':2,'c':3}\n",
    "dico.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a3ba7e-8436-43f7-924a-6c47ade287a2",
   "metadata": {},
   "source": [
    "Cette séquence peut être converties en liste avec l'instruction *list*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "df0e0508-f63a-447e-ac4c-5ee878266cfe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dico.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e53d4beb-68f5-4d91-9862-eca97de7f05a",
   "metadata": {},
   "source": [
    "### Exercice 1\n",
    "Ecrire une fonction qui prend en argument un dictionnaire et qui renvoie une liste qui contient les clés du dictionnaire et une liste qui contient ses valeurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "28edc5d2-6b1f-46fa-9f69-1083d2408206",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex1(dico):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "952214bd-e711-456d-9173-474bffa8b706",
   "metadata": {},
   "outputs": [],
   "source": [
    "ex1(dico1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28cd5129-f7e7-40d5-a37f-61e837807f25",
   "metadata": {},
   "source": [
    "Les clés sont considérés comme les éléments du dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0ce16ba8-7970-4438-bf14-19e0a8acaeae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "dico={'a':1,'b':2,'c':3}\n",
    "print('c' in dico) # print('c' in dico.keys())\n",
    "print('d' in dico) # print('d' in dico.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eb2b922-3ce1-4555-8e5a-0f06e97bc462",
   "metadata": {},
   "source": [
    "La méthode *keys()* sera donc assez peu utilisée."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f64c0c-c360-4031-bed0-8ebf508c3ff3",
   "metadata": {},
   "source": [
    "### Exerice 2\n",
    "Ecrire une fonction qui prend en argument un dictionnaire et qui renvoie la liste de ses valeurs sans utiliser *values()* ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "da12d0cc-80f3-4046-8248-8fb4ea4f6fbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex2(dico):\n",
    "   ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ac8d0300-4abd-4f18-ac1a-c940fb209918",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Paris', 'Berlin', 'Madrid']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex2(dico1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3a44a8-f219-41bf-bc15-48eeb2725079",
   "metadata": {},
   "source": [
    "### Exercice 3\n",
    "Soit *dico* un dictionnaire contenant un stock d'articles. \n",
    "La clé est le nom de l'article, la valeur est une liste contenant le prix et la quantité de l'article.\n",
    "\n",
    "Ecrire une fonction qui renvoie la valeur du stock et le nombre d'articles sous forme de tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3d5a8507-5b3b-460b-8377-26282804eeea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex3(dico):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4b5e214-cb1b-4e0c-a7cc-ea3fd6a63b44",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1133.0, 285)\n"
     ]
    }
   ],
   "source": [
    "dico3={'stylo billes (lot de 10)':[6,50],\n",
    "   'carnet de notes (A5, 100 pages)':[4.50,25],\n",
    "   'classeur':[3.25,20],\n",
    "   'agrafeuse':[8.95,30],\n",
    "   'surligneur':[0.90,100],\n",
    "   'post-it (bloc de 100)':[4.95,60]\n",
    "  }\n",
    "print(ex3(dico3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96d03696-0740-47f6-88c7-5ab8c768a29a",
   "metadata": {},
   "source": [
    "### Exercice 4\n",
    "Ecrire une fonction qui prend en argument un dictionnaire dont toutes les valeurs sont des chaînes de caractères distinctes et qui renvoie le dictionnaire inversé (les clés de l'un sont les valeurs de l'autre)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "07cccdfb-93f2-4464-8fc4-fa82de7ab2b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ex4(dico):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "eb8032d9-d4d2-4f99-9c90-7772d238431d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'France': 'Paris', 'Allemagne': 'Berlin', 'Espagne': 'Madrid'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Paris': 'France', 'Berlin': 'Allemagne', 'Madrid': 'Espagne'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(dico1)\n",
    "ex4(dico1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fdf5c6b-fe87-4c98-874e-e9b37c5ed126",
   "metadata": {},
   "source": [
    "### Exercice 5\n",
    "Ecrire une fonction *frequence(ch)* qui prend en paramètre une chaîne de caractères *ch* et qui renvoie un dictionnaire dont les clés sont les caractères de la chaîne *ch* et les valeurs sont les fréquences de la clé dans la chaîne *ch*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7d7f38ba-ab5b-4415-bd7b-6b7193de979e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def frequence(ch):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d1f93cf2-528c-4e19-b6bb-b8fc3a57b0d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d': 1, 'i': 3, 'c': 1, 't': 1, 'o': 1, 'n': 2, 'a': 1, 'r': 1, 'e': 1}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frequence('dictionnaire')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a00cc4c-10b7-42a3-9083-3f80e944e731",
   "metadata": {},
   "source": [
    "### Exercice 6\n",
    "1) Ecrire une fonction *mots(texte)* qui recherche tous les mots d'un texte et qui construit un dictionnaire. \n",
    "Les clés de ce dictionnaire sont les mots du texte. A chaque mot, le dictionnaire associe  le nombre de fois qu'il apparaît.\n",
    "2) Tester la fonction avec le teste contenu dans le fichier *recherche_mots.txt*. Afficher le nombre de mots distincts, ainsi que les mots qui apparaissent plus de 50 fois.\n",
    "\n",
    "On pourra utiliser la méthode *split()* qui découpe une chaîne en liste. On peut préciser un séparateur, par défaut le séparateur est l'espace. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "bc3a9990-d6b8-427a-8c5a-8af78880231f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Longtemps,', 'je', 'me', 'suis', 'couché', 'de', 'bonne', 'heure']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A='Longtemps, je me suis couché de bonne heure'\n",
    "A.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ad3cc99c-567a-49fd-b155-47ee76433d6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mots(texte):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "dfa81cc5-8813-42bd-b7e0-5b945a4991fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre de mots différents:  940\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('de', 108), ('à', 56), ('le', 58), ('la', 75), ('et', 55)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fichier = open(\"recherche_mots.txt\", \"r\")\n",
    "texte=fichier.readline()\n",
    "dico=mots(texte)\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebbe0e1d-ce64-4ae0-959a-a50d50a38b31",
   "metadata": {},
   "source": [
    "### Exercice 7\n",
    "On considère $\\Omega$ un ensemble dont les éléments sont stockés dans la liste $\\Omega$ et $A$ une partie de $\\Omega$.\n",
    "\n",
    "On dit qu'un dictionnaire représente une partie de $\\Omega$ si l'ensemble de ses clés correspond à $\\Omega$ et ses valeurs sont des booléens.\n",
    "Par exemple si $\\Omega=\\{1,2,3,4,5,6,7,8,9\\}$ et $A=\\{2,3,5,7\\}$, le dictionnaire représentant $A$ est:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11c10a53-ae95-4cd7-a3e4-014bb7f2e48a",
   "metadata": {},
   "outputs": [],
   "source": [
    "{'1':False, '2':True, '3':True, '4':False, '5':True, '6':False, '7':False, '8':False, '9':False}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f36137b6-c7a1-4955-9a18-003e36bf39b6",
   "metadata": {},
   "source": [
    "1) Ecrire une fonction *cree_dico(A,omega)* prenant en argument la liste des éléments de $A$ et qui renvoie un dictionnaire dont les clés sont les éléments de $\\Omega$ et les valeurs *True* ou *False* suivant que la clé appartient ou non à $A$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "8b7de36c-07ed-4175-991c-5a3393e69329",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cree_dico(A,omega):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "18505255-dc40-465c-b372-763568500847",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: False,\n",
       " 2: True,\n",
       " 3: True,\n",
       " 4: False,\n",
       " 5: True,\n",
       " 6: False,\n",
       " 7: True,\n",
       " 8: False,\n",
       " 9: False}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cree_dico([2,3,5,7],[1,2,3,4,5,6,7,8,9])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0590adb-e0a5-4cd7-827a-8a0156a16abf",
   "metadata": {},
   "source": [
    "2) Ecrire une fonction *liste* prenant en argument un dictionnaire représentant une partie de $\\Omega$ et qui renvoie la liste des éléments de $\\Omega$ et la liste des éléments de la partie de $\\Omega$ correspondant au dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "43fbd7ab-f8b2-4d86-850e-50ac27f2d837",
   "metadata": {},
   "outputs": [],
   "source": [
    "def liste(dico):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "16ee452a-4e61-4266-a8a9-fb990bff2c61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([2, 3, 5, 7], [1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "liste({1: False, 2: True, 3: True, 4: False, 5: True, 6: False, 7: True, 8: False, 9: False})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f79ed342-2d42-461a-8bb7-52b5fed86464",
   "metadata": {},
   "source": [
    "3) Ecrire des fonctions *union(dicA,dicB)* et *intersection(dicA,dicB)* dont les arguments sont des dictionnaires représentant des parties $A$ et $B$ de $\\Omega$ et qui renvoient respectivement les dictionnaires correspondant à $A\\cup B$ et $A\\cap B$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ce1a12b5-0157-4af7-8e54-8aa7e7454317",
   "metadata": {},
   "outputs": [],
   "source": [
    "def union(dicA,dicB):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "3a618454-3e80-49f6-bb62-570dbf7964a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def intersection(dicA,dicB):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "340895c6-12ff-4fe7-acc1-775818de71a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
      "([2], [1, 2, 3, 4, 5, 6, 7, 8, 9])\n"
     ]
    }
   ],
   "source": [
    "omega=[1,2,3,4,5,6,7,8,9]\n",
    "A=[2,3,5,7]\n",
    "B=[2,4,6,8]\n",
    "dicA=cree_dico(A,omega)\n",
    "dicB=cree_dico(B,omega)\n",
    "dicU=union(dicA,dicB)\n",
    "dicI=intersection(dicA,dicB)\n",
    "print(liste(dicU))\n",
    "print(liste(dicI))\n"
   ]
  }
 ],
 "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}