{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>  Structure de données Associative : Les Dictionnaires </h1>\n",
    "\n",
    "<p> Nous allons étudier un autre type abstrait de données : les dictionnaires aussi appelés tableau associatif.</p>\n",
    "\n",
    "On retrouve une structure qui ressemble, à première vue, beaucoup à un tableau (à chaque élément on associe un indice de position).  <br>\n",
    "<p> Mais au lieu d'associer chaque élément à un indice de position, dans un dictionnaire, on associe chaque élément (on parle de valeur dans un dictionnaire) à une clé.</p>\n",
    "<p> Un dictionnaire contient des couples clé:valeur (chaque clé est associée à une valeur). </p> \n",
    "Exemples de couples clé:valeur => prenom:Kevin, nom:Durand, date-naissance:17-05-2005.  <br>\n",
    "<li> prenom, nom et date sont des <strong>clés </strong> </li> \n",
    "<li> Kevin, Durand et 17-05-2005 sont des <strong>valeurs</strong> </li>\n",
    "\n",
    "Les opérations classiques que l'on peut effectuer sur un dictionnaire sont :\n",
    "\n",
    "- Ajouter une nouvelle entrée au dictionnaire en créant une nouvelle clé\n",
    "- Modifier la valeur associée à une clé existante\n",
    "- Suprimer une entrée dans un dictionnaire \n",
    "- Rechercher la présence d'une clé dans un dictionnaire.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>  Rappels sur les fonctions essentielles sur les dictionnaires </h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  A) Créer un dictionnaire\n",
    "\n",
    "Le dictionnaire se crée à l’aide d’accolade ( quand les listes sont créées avec des crochets et les tuples avec des parenthèses ).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de d1 un dictionnaire vide\n",
    "d1 = {}  \n",
    "\n",
    "# on demande son type \n",
    "type(d1)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Pour créer une clé, on la nomme entre guillemets, le tout entre crochet.  \n",
    "On lui affecte sa valeur à l’aide du signe égal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Personnage1={}\n",
    "Personnage1[\"Nom\"]=\"Bond\"\n",
    "Personnage1[\"Prénom\"]=\"James\"\n",
    "Personnage1[\"acteurs\"]=(\"Connery\",\"Moore\",\"Brosnan\",\"Craig\")\n",
    "Personnage1[\"année\"]=1953\n",
    "Personnage1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "On peut aussi créer directement un dictionnaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joueur1={\"Nom\":\"Maradona\",\"Prénom\":\"Diego\",\"Coupe du monde\":2}\n",
    "joueur1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "On peut créer un dictionnaire à partir d'une liste  L par la fonction dict(L) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# liste de tuples\n",
    "L=[(\"Bob\",12),(\"Sophie\",8),(\"Alice\",20),(\"Olivier\",12)]\n",
    "d3=dict(L)\n",
    "print(d3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# liste de listes\n",
    "L=[[\"Marc\",13],[\"Léa\",15]]\n",
    "d4=dict(L)\n",
    "print(d4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B) Obtenir une valeur d'un dictionnaire, la taille d'un dictionnaire"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "on récupere la valeur d'une clé par dic[\"clé\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joueur1={\"Nom\":\"Maradona\",\"Prénom\":\"Diego\",\"Coupe du monde\":2}\n",
    "a=joueur1[\"Prénom\"]\n",
    "a"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "un dictionnaire est une collection donc on peut avoir son nombre d'élements par len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(joueur1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C) Modifier un dictionnaire : c'est possible car les dictionnaires sont mutables"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Pour ajouter, il suffit de créer une nouvelle clé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Personnage1[\"nb de films\"]=26\n",
    "Personnage1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour modifier la valeur d'une clé, on procède comme une variable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# j'ai oublié des acteurs\n",
    "Personnage1[\"acteurs\"]=(\"Connery\",\"Lazenby\",\"Moore\",\"Brosnan\",\"Dalton\",\"Craig\")\n",
    "Personnage1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour supprimer une clé, on utilise la méthode del (ou la méthode pop si on veut conserver la valeur associée à la clé supprimée en mémoire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(d3[\"Bob\"])\n",
    "d3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Fruits = { \"pomme\": 2, 'orange': 3, 'raisin': 4 }\n",
    "element = Fruits.pop('pomme')\n",
    "print(element)\n",
    "Fruits"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Enfin, pour copier un dictionnaire de façon indépendante, on utilise la méthode deepcopy à importer du module copy, sinon la modification d'un dictionnaire modifiera l'autre. Cette remarque s'applique aussi aux listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "d1 = {'a':1}\n",
    "d2 = copy.deepcopy(d1)\n",
    "d2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  D) Parcourir un dictionaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les itérateurs pour les dictionnaires\n",
    "\n",
    "Trois méthodes permettent de parcourir soit par :\n",
    "-  l'ensemble des paires clés-valeurs `items()`\n",
    "-  l'ensemble des clés `keys()`\n",
    "-  l'ensemble des valeurs `values()` \n",
    "\n",
    "On peut itérer sur un dictionnaire grâce à l'une de ces méthodes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemple** : Les notes d'un élève par un dictionnaire.  \n",
    "Il contient les couples clé :matière , valeur :note.  \n",
    "On peut accéder au notes en interrogeant sur la matière."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes = {'Maths':18,'NSI':15,'LV1':12,'EPS':16,\"Philo\":8}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Si on veut recupérer chaque clé et sa valeur, on itère sur notes.items(): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for m,n in notes.items():\n",
    "    print(m, '->',n)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Si on veut juste les clés, on itère sur notes.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"matières étudiées : \", end = \"\")\n",
    "for m in notes.keys():\n",
    "      print(m,end=' ; ')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Si on veut juste les valeurs, on itère sur notes.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=0\n",
    "for n in notes.values():\n",
    "    s=s+n\n",
    "print (\"la moyenne est de \", s/len(notes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi interroger l'appartenance d'une valeur ou d'une clé grace à l'expression `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Espagnol' in notes.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "18 in notes.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### E) Tri d'un dictionnaire\n",
    "On peut utiliser la fonction sorted()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EPS', 'LV1', 'Maths', 'NSI', 'Philo']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# selon les clés  (ici c'est l'ordre alphabétique):\n",
    "sorted(notes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Philo', 'NSI', 'Maths', 'LV1', 'EPS']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# à l'envers...\n",
    "sorted(notes,reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EPS', 'LV1', 'Maths', 'NSI', 'Philo']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# selon les valeurs\n",
    "sorted(notes,key=lambda x:x[0])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Dans notre exemple, la valeur est unique. Si celle-ci est un tuple (notes,coefficient) et que l'on trier selon les coefficient, on modifie le paramètre du x :   sorted(notes,key=lambda x:x[1])  x[1] est le coeeficient car indice 1 du tuple  "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "remarque : si vous voulez enregistrer dans un fichier le contenu d'un dictionnaire, utilisez le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"fich.txt\", \"w\") as f:\n",
    "    for m,n in notes.items():\n",
    "        f.write(m+\":\"+str(n)+\"\\n\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Exercice 1 </h3>\n",
    "<p> Écrire une fonction occurrences(text) renvoyant un dictionnaire avec le nombre d’occurrences de chaque caractère dans un texte</p>\n",
    "<p> A tester avec la phrase suivante : <br> \"La révolution informatique fait gagner un temps fou aux hommes, mais ils le passent avec leur ordinateur !\" </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Exercice 2 </h3> \n",
    "<p> Les réponses correctes d'un QCM de NSI sont stockées dans un dictionnaire nommé reponses_valides. <br> Les clés sont des chaînes de caractères de la forme \"Q1\".<br> Les valeurs possibles sont des chaînes de caractères correspondant aux quatre réponses \"a\",\"b\",\"c\",\"d\".</p>\n",
    "\n",
    "Exemple : reponses_valides = {\"Q1\":\"c\",\"Q2\":\"a\",\"Q3\":\"d\",\"Q4\":\"c\",\"Q5\":\"b\"}\n",
    "\n",
    "<p> Les réponses données par Alice sont stockées dans le dictionnaire reponses_Alice dont voici un exemple possible :<br>\n",
    "\n",
    "reponses_Alice = {\"Q1\":\"b\",\"Q2\":\"a\",\"Q3\":\"d\",\"Q5\":\"a\"} </p>\n",
    "\n",
    "<p> Lorsqu'Alice n'a pas répondu à une question, il n'y a pas de clef correspondant au nom de l'exercice.</p>\n",
    "\n",
    "<p>La notation d'un QCM de NSI est la suivante : 3 points par réponse correcte, -1 point par réponse incorrecte et 0 si l'on n'a pas répondu</p>\n",
    "\n",
    "<h4> Ecrire la fonction correction_QCM_Alice(reponses_Alice,reponses_valides) qui, à partir des dictionnaires reponses_Alice et reponses_valides passées en paramètres renvoie le nombre de points obtenus au QCM par Alice.</h4>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def correction_QCM_Alice(reponses_Alice,reponses_valides):\n",
    "    pass"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}