{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> Tri dans une table </h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Introduction</h3>\n",
    "\n",
    "<p>En Python, avec l'opérateur `<` (ou `>`, `==`, `<=`, `>=`), il est possible de comparer des nombres</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou des chaînes de caractères (c'est l'ordre alphabétique qui est alors utilisé)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Arthur' < 'Bérénice'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Gaëlle' < 'Boris'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Fonctions de tri offertes par Python </h2>\n",
    "\n",
    "<p> Python offre deux fonctions permettant d'effectuer des opérations de tri.</p>\n",
    "\n",
    "## La fonction `sorted` \n",
    "\n",
    "Celle-ci prend en argument un tableau et renvoie un *nouveau tableau*, trié, contenant les mêmes éléments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = [12, 5, 3, 6, 8, 10]\n",
    "t1=sorted(t)\n",
    "print(t1)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit que `t` n'a pas été modifié."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction permet aussi de trier des chaînes de caractères, en utilisant l'odre alphabétique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([\"poire\", \"pomme\", \"cerise\", 'kiwi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La fonction `sort` \n",
    "Celle-ci s'applique à un tableau, ne renvoie rien, mais *modifie* le tableau d'origine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t.sort()\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit que `t` a été modifié."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi trier directement un tableau de chaînes de caractères avec `sort`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fruits = [\"poire\", \"pomme\", \"cerise\", 'kiwi']\n",
    "fruits.sort()\n",
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1** : Que vaut le tableau `t` après l'exécution des instructions suivantes ? *(Vérifiez ensuite en écrivant et en exécutant ces instructions dans une nouvelle cellule)*.\n",
    "\n",
    "```python\n",
    "t = [4, 5, 1, 3, 7]\n",
    "t.sort()\n",
    "t[0] = 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réponse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2** : Que valent les tableaux `t` et `t1` après l'exécution des instructions suivantes ? *(Vérifiez ensuite en écrivant et en exécutant ces instructions dans une nouvelle cellule)*.\n",
    "\n",
    "```python\n",
    "t = ['Adèle', 'Zoé', 'Hugo', 'Clément']\n",
    "t1 = sorted(t)\n",
    "t1[0] = 'Arnaud'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réponse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3**: Quel est le contenu du tableau `tab` à l'issue des instructions suivantes ? *(Vérifiez ensuite en écrivant et en exécutant ces instructions dans une nouvelle cellule)*.\n",
    "\n",
    "```python\n",
    "tab = ['2', '1', '3', '12', '10', '5']\n",
    "tab.sort()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réponse : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ordre lexicographique\n",
    "\n",
    "Il est possible de trier des données selon plusieurs critères.<br> Ainsi, lorsque l'on trie selon un premier critère puis, à valeurs égales, selon un second critère, on appelle cela un *ordre lexicographique*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2, 3) < (2, 8) # les deux premiers éléments sont égaux donc le tri se fait sur les seconds éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2, 3) < (2, 1) # les deux premiers éléments sont égaux donc le tri se fait sur les seconds éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1, 5) < (2, 3) # les deux premiers éléments ne sont pas égaux donc le tri se fait directement sur les premiers éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions `sorted` et `sort` utilisent cet ordre lexicographique pour trier un tableau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sorted([(2, 3), (1, 5), (2, 8), (2, 1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 4 :** Que renvoie l'expression suivante ? *(Vérifiez ensuite en écrivant et en exécutant cette instruction dans une nouvelle cellule)*.\n",
    "\n",
    "```Python\n",
    "sorted([(1, 3), (1, 2), (2, 4), (2, 1)]) \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réponse : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 5 :** Que renvoie l'expression suivante ? *(Vérifiez ensuite en écrivant et en exécutant cette instruction dans une nouvelle cellule)*.\n",
    "\n",
    "```Python\n",
    "sorted([(1, \"poires\"), (3, \"abricot\"), (1, \"bananes\"), (2, \"kiwi\"),(2,\"ananas\")]) \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Réponse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Nous allons pouvoir trier dans notre table pays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Par exemple, on peut vouloir afficher la liste de tous les pays par ordre alphabétique ou bien encore trier les pays selon leur superficie, selon le nombre d'habitants...</p>\n",
    "<br>\n",
    " <p>Avant celà, il faut la créer à partir du fichier csv et modifier le type de certains champs </p>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "Pays = []\n",
    "with open('countries.csv', newline='',encoding=\"UTF-8\") as csvfile:\n",
    "    reader = csv.DictReader(csvfile, delimiter=';')   # Objet DictReader (itérateur)\n",
    "    for ligne in reader:\n",
    "        Pays.append(dict(ligne))     # Conversion du type OrderedDict en dictionnaire\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on doit transformer le type des champs Population et Superficie\n",
    "for p in Pays:\n",
    "    p[\"Population\"]=int(p[\"Population\"])\n",
    "    p[\"Superficie\"]=float(p[\"Superficie\"])\n",
    "print(Pays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les deux fonctions `sorted` et `sort` sont incapables de comparer deux dictionnaires directement .<br> En particulier, on ne peut pas appliquer directement ces fonctions à notre tableau `pays` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(Pays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Trier selon un critère unique </h2>\n",
    "\n",
    "<p> Pour pouvoir utiliser ces fonctions, il va falloir leur donner en paramètre ce que l'on appelle une *clé*. ( attention ne pas confondre ce terme avec les clés d'un dictionnaire <br> Cette clé est en fait une fonction qui prend en paramètre un dictionnaire et qui renvoie la valeur du champ que l'on souhaite comparer. Cela doit nécessairement être des éléments que Python sait comparer (nombres, chaînes de caractères, tuples).\n",
    "\n",
    "Si on veut trier les pays par l'ordre alphabétique des monnaies, on définit la fonction suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def monnaie(p):\n",
    "    \"\"\" fonction qui renvoie la valeur de clé Monnaie du dictionnaire p \"\"\"\n",
    "    return p[\"Monnaie\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite, on peut appeler la fonction `sorted` sur le tableau `pays` en précisant qu'il faut utiliser la fonction `monnaie` à chaque fois que deux éléments du tableau doivent être comparés. <br> On l'indique en passant `key=monnaie` à la fonction `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pays_trié_monnaie = sorted(Pays, key=monnaie)\n",
    "pays_trié_monnaie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Affichage des monnaies et noms de pays\n",
    "for p in pays_trié_monnaie:\n",
    "    print(p[\"Monnaie\"], p[\"Name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on veut trier plutôt dans l'ordre inverse, c'est-à-dire du plus grand au plus petit, il faut passer une autre option à la fonction `sorted`, à savoir `reverse=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pays_trié_monnaie_bis = sorted(Pays, key=monnaie,reverse=True)\n",
    "for p in pays_trié_monnaie_bis:\n",
    "    print(p[\"Monnaie\"],p[\"Name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 6 :** Triez la table `pays` suivant la population décroissante. <br>*Indication :* n'oubliez pas de commencer par définir la fonction qui servira de clé de tri à la fonction `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# à vous de jouer !\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Trier selon plusieurs critères </h2>\n",
    "\n",
    "Imaginons que l'on souhaite trier les pays selon leur continent, puis, si des pays sont sur le même continent, les trier par ordre alphabétique.\n",
    "\n",
    "On peut alors utiliser le fait que la fonction `sorted` réalise l'ordre lexicographique. Il suffit de définir la fonction de tri suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def continent_puis_nom(p):\n",
    "    return (p[\"Continent\"], p[\"Name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fonction renvoie pour chaque élève `eleve`, la paire (année, prénom). En utilisant cette clé, la fonction `sorted` va utiliser cette fonction pour comparer deux pays, en respectant l'ordre lexicographique (d'abord le continent, puis en cas d'égalité le nom)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_a_afficher = sorted(Pays, key=continent_puis_nom)\n",
    "table_a_afficher\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in table_a_afficher:\n",
    "    print (p[\"Continent\"],p[\"Name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 7 a) :** Afficher les pays par continent et superficie croissante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 7 b) :** Comment faire pour triez les pays par continent puis par superficie décroissante ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 8 :** Obtenir la liste des 10 pays les plus peuplés de la table Pays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 9 :** Obtenir la liste des 10 pays d'Afrique les moins grands en superficie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 10:** Obtenir la liste des pays d'Europe selon leur densité dans l'ordre décroissant "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 11:** Obtenir la liste des pays trié par continent, puis par monnaie, puis par population . On les affichera par continent, monnaie et population respectives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": 2
}