{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types construits : les tuples\n",
    "\n",
    "Un p-uplet (comprendre un couple, un triplet, un quadruplet etc.), est une suite ordonnée d’éléments qui peuvent être chacun de n’importe quel type. En Python on parle de tuple.\n",
    "\n",
    "## 1- Création d'un tuple :\n",
    "On peut créer un tuple en écrivant  n éléments séparés par des virgules. Les parenthèses ne sont pas indispensables, mais il est préférable de les mettre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hdf =  ('Aisne', 'Nord', 'Oise','Pas de Calais', 'Somme')\n",
    "print(type(hdf))\n",
    "print(hdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2- Opérations sur les tuples\n",
    "\n",
    "Un tuple étant une séquence, on peut utiliser les fonctions et opérateurs communs à tous les types de séquences (Cf 6.5.2 Propriétés communes aux séquences dans le livret « Types et valeurs de base »\n",
    "Exemples :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combien d’éléments dans le tuple hdf :\n",
    "\n",
    "\n",
    "# Quel est l’élément du tuple hdf ayant pour valeur d’index 2 ?   \n",
    "\n",
    "\n",
    "# L’élément ‘Nord’ est-il dans le tuple hdf ?\n",
    "\n",
    "\n",
    "# L’élément ‘NORD’ est-il dans le tuple hdf ?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parcours d’un tuple avec les instructions for … in :\n",
    "On cherche à obtenir l'affichage suivant :\n",
    "\n",
    "Les départements de la région HdF sont :\n",
    "- Aisne\n",
    "- Nord\n",
    "- Oise\n",
    "- Pas de Calais\n",
    "- Somme\n",
    "\n",
    "Rédiger ci-dessous le code nécessaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Les départements de la région HdF sont :')\n",
    "???\n",
    "...\n",
    "???\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Un tuple n'est pas muable : on ne peut pas le modifier (ajouter, enlever ou modifier un ou plusieurs des éléments qui le constituent :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on essaye de modifier le deuxième item du tuple hdf :\n",
    "hdf[1] = \"C'est le NOOORD !\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice : \n",
    "\n",
    "![image : regions.png](images/regions.png)\n",
    "\n",
    "Créer un tuple *normandie* contenant les départements de cette région, puis **concaténer** ce tuple avec le tuple hdf pour obtenir un nouveau tuple : *super_region* :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3- Créer un tuple de tuples :\n",
    "On peut à chaque département lui associer son numéro. On peut former ainsi un tuple dont la structure serait : *(Numéro, Nom)*. \n",
    "Une région serait alors représentée par un tuple de tuples dont la structure serait :\n",
    "*((Numéro_1, Nom_1), (Numéro_2, Nom_2), …, (Numéro_n, Nom_n))*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Créer le nouveau tupple hdf2 correspondant à cette structure :\n",
    "hdf2 = \n",
    "# et afficher son contenu\n",
    "print(hdf2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On souhaite obtenir un affichage différent, tel que celui-ci :\n",
    "\n",
    "N° : 2  =  Aisne\n",
    "\n",
    "N° : 59  =  Nord\n",
    "\n",
    "N° : 60  =  Oise\n",
    "\n",
    "N° : 62  =  Pas de Calais\n",
    "\n",
    "N° : 80  =  Somme\n",
    "\n",
    "Pour réaliser cela, il faut comprendre que chaque élément de ce tuple :\n",
    "((2,\"Aisne\"), (59,\"Nord\"),(60, \"Oise\"), (62,\"Pas de Calais\"), (80,\"Somme\"))\n",
    "par exemple (59,\"Nord\") est lui même un tuple dont :\n",
    "    + le premier item (le numéro) est accessible par son index : 0\n",
    "    + le deuxième item (le nom) est accessible par son indice : 1\n",
    "Ecrire le code permettant de présenter le contenu de ce tuple comme proposé ci-dessus :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# travail sur un tuple de tuples :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice :\n",
    " On donne, en km², la superficie de chacun de ces départements :\n",
    " - Aisne : 7362\n",
    " - Nord : 5743\n",
    " - Oise : 5860\n",
    " - Pas de Calais : 6671\n",
    " - Somme : 6170\n",
    "\n",
    "1- Réécrire le tuple hdf pour y intégrer ces données sous forme d'entiers. Chaque département est représenté par un tuple : ( N° du dpt , \"Nom du dpt\" , Superficie).\n",
    "\n",
    "2- Ecrire une fonction superficie_région() qui prend en paramètre un tuple de tuples organisés comme décrit ci-dessus et qui renvoie la superficie totale de la région. La fonction doit pouvoir être utilisée avec une région quelconque.\n",
    "\n",
    "3- Appliquer la fonction superficie_region() au tuple hdf pour déterminer la superficie de la région Hauts de France. Vérifier que le résultat renvoyé par votre fonction est correct.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nouvelle version du tuple hdf :\n",
    "hdf = ???\n",
    "\n",
    "\n",
    "# définition de la fonction superficie_region() :\n",
    "def superficie_region(region):\n",
    "    \"\"\" fonction qui calcule la superficie totale d'une région\n",
    "    :param region: (tuple) un tuple de tuples : ((N° du dpt -> int , \"Nom du dpt\" -> str , Superficie -> int), (.,.,),...)\n",
    "    :return: (int) la superficie totale\n",
    "    \"\"\"\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "    return superficie\n",
    "\n",
    "# application de la fonction au tuple hdf :\n",
    "print('La superficie de la région Hauts de France = ', ??? , ' km²')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image : bretagne.png](images/bretagne.png)\n",
    "\n",
    "4- La région Bretagne est constituée de quatre départements :\n",
    "\n",
    "\n",
    "| Numéro |        Nom        |    Superficie  |\n",
    "| -------| ----------------- | -------------- |\n",
    "|   22   |  Côtes d'Armor    |       6878     |\n",
    "|   29   |   Finistère       |       6733     |\n",
    "|   35   |  Ille et Vilaine  |       6775     |\n",
    "|   56   |   Morbihan        |       6823     |\n",
    "\n",
    "4.1 - Créer un tuple pour représenter la région Bretagne sur le même modèle que le tuple HdF.\n",
    "\n",
    "4.2 - Appliquer la fonction surface_region à ce tuple. En déduire la superficie de la région Bretagne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création du tuple représentant la région Bretagne :\n",
    "\n",
    "\n",
    "# Calcul de la superficie de cette région\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4- Ecrire une fonction renvoyant plusieurs résultats :\n",
    "\n",
    "On peut demander à une fonction de renvoyer non pas un, mais plusieurs résultats simultanément. Ces résultats, séparés par une virgule constituent ensemble un tuple :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# la fonction suivante doit renvoyer le périmètre et l'aire' d'un rectangle\n",
    "# la compléter :\n",
    "def rectangle(longueur,largeur):\n",
    "    # renvoi du périmètre et de l'aire :\n",
    "    return ???, ???\n",
    "\n",
    "# utilisation de la fonction :\n",
    "print(rectangle(3,5))\n",
    "\n",
    "# test du type de l'objet renvoyé par la fonction :\n",
    "print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercices\n",
    "\n",
    "#### 1- Division euclidienne :\n",
    "La division euclidienne ou division entière est une opération qui, à deux entiers naturels appelés *dividende* et *diviseur*, associe deux autres entiers appelés *quotient* et *reste*. (def. Wikipédia)\n",
    "\n",
    "En Python, il y a deux opérateurs mathématiques qui vont nous permettre d'écrire une fonction que l'on notera **div_euclid(dividende, diviseur)** :\n",
    "\n",
    "  - l'opérateur *division entière* : //\n",
    "  - l'opérateur *modulo* : %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# essayer ces deux opérations :\n",
    "print(7//3)\n",
    "print(7%3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utiliser ces opérateurs pour construire la fonction div_euclide(dividende, diviseur) demandée :\n",
    "def div_euclide(dividende, diviseur):\n",
    "    \"\"\" division euclidienne de dividende par diviseur\n",
    "    :param dividende: (int) la valeur à diviser\n",
    "    :param diviseur: (int) le diviseur\n",
    "    :return: (tuple) (quotient -> int, reste ->int)\n",
    "    \"\"\"\n",
    "    return ???, ???\n",
    "\n",
    "# test de la fonction :\n",
    "print(div_euclide(7,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2- Géométrie dans un plan :\n",
    "Dans un plan, un point est défini par deux coordonnées x et y. En Python, on pourra donc définir un point par un tuple *point = (x,y)*.\n",
    "\n",
    "Soient deux points A et B du plan, écrire :\n",
    "- une fonction renvoyant les coordonnées du milieu M du segment \\[AB]\n",
    "- une fonction renvoyant la longueur du segment \\[AB] (autrement dit la distance du segment \\[AB])\n",
    "\n",
    "Remarque : le calcul de la distance (dite euclidienne) entre deux points A et B :\n",
    "\n",
    "![distance_euclidienne.png](images/distance_euclidienne.png)\n",
    "\n",
    " nécessite de savoir calculer : \n",
    "   - une puissance : en Python c'est l'opérateur ** suivi de la valeur de puissance voulue\n",
    "   - la racine carrée : cette fonction **n'est pas native dans le langage Python**, mais elle est présente dans le module **math** : **sqrt(nbre)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# milieu(pt1,pt2):\n",
    "def milieu(pt1, pt2):\n",
    "    \"\"\" fonction qui renvoie les coordonnées du milieu du segment [pt1 pt2]\n",
    "    :param pt1: (tuple) coordonnées (x1, y1) du point pt1\n",
    "    :param pt2: (tuple) coordonnées (x2, y2) du point pt2\n",
    "    :return: (tuple) coordonnées du milieu du segment [pt1 pt2]\n",
    "    \"\"\"\n",
    "    return ???, ???\n",
    "\n",
    "def distance_euclidienne(pt1, pt2):\n",
    "    \"\"\" fonction qui renvoie la distance euclidienne entre deux points du plan\n",
    "    :param pt1: (tuple) un tuple de coordonnées '(x1, y1)' définissant le point pt1\n",
    "    :param pt2: (tuple) un tuple de coordonnées '(x2, y2)' définissant le point pt2\n",
    "    :return: (float) la distance euclidienne entre pt1 et pt2\n",
    "    Exemple :\n",
    "    >>> A = (2, 5)\n",
    "    >>> B = (3, 7)\n",
    "    >>> distance_euclidienne(A, B)\n",
    "    >>> 2.23606797749979\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# test des fonctions :\n",
    "A = (2, 5)\n",
    "B = (3, 7)\n",
    "print('Le milieu M du segment a pour coordonnées : ', ???)\n",
    "print('Le segment a pour longueur : ', ???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5- Affectation multiple - permutations\n",
    "\n",
    "### 5.1 - Affectation multiple\n",
    "\n",
    "Python autorise l'affectation multiple : sur une même migne de code on affecte des valeurs différentes à des variables différentes.\n",
    "\n",
    "Compléter le code suivant pour afficher les valeurs affectées aux variables a et b :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 3, 4\n",
    "???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2- Permutations\n",
    "\n",
    "![permutation_variables.png](images/permutation_variables.png)\n",
    "\n",
    "Il est parfois utile de permuter le contenu de deux cases mémoires (par exemple lorsque l'on fait un tri de données). L'idée simpliste donnée par le schéma 1 ne peut pas fonctionner car si l'on met le contenu de 'b' dans 'a', alors on écrase le contenu de 'a' qui est alors perdu...\n",
    "C'est donc le schéma 2 qu'il est nécessaire de suivre : on utilise une 3ème case mémoire ('c') pour sauvegarder momentanément le contenu de 'a' par exemple, avant de transférer le contenu de 'b' dans 'a', puis de récupérer le contenu de 'c' (= ce que contenait 'a') pour aller le remettre dans 'b'.\n",
    "\n",
    "Dans beaucoup de langages il est nécessaire d'écrire trois lignes de code pour réaliser cette permutation, conformément au schéma 2.\n",
    "Cependant, Python permet une écriture très simple de la permutation en écrivant :\n",
    "\n",
    "```Python\n",
    "a, b = b, a \n",
    "```\n",
    "\n",
    "Compléter le code suivant pour afficher les valeurs affectées aux variables a et b suite à cette opération :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 3, 4\n",
    "a, b = b, a\n",
    "???"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}