tnsi_tuples.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "jupytext": {
      "cell_metadata_filter": "all",
      "notebook_metadata_filter": "all,-language_info,-toc,-jupytext.text_representation.jupytext_version,-jupytext.text_representation.format_version",
      "text_representation": {
        "extension": ".md",
        "format_name": "myst"
      }
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "colab": {
      "name": "tnsi.tuples.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/srenouf/Tnsi/blob/master/tnsi_tuples.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJYqu-6LznPL",
        "colab_type": "text"
      },
      "source": [
        "# Les tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uq3-F1vVznPP",
        "colab_type": "text"
      },
      "source": [
        "### Noter un tuple\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "utVZp58BznPR",
        "colab_type": "text"
      },
      "source": [
        "On peut construire un tuple à deux éléments de quatre façons :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bu6bW4rTznPU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# sans parenthèse ni virgule terminale\n",
        "couple1 = 1, 2\n",
        "# avec parenthèses\n",
        "couple2 = (1, 2)\n",
        "# avec virgule terminale\n",
        "couple3 = 1, 2,\n",
        "# avec parenthèses et virgule\n",
        "couple4 = (1, 2,)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cflCKKGWznPd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# toutes ces formes sont équivalentes ; tester\n",
        "couple1 == couple4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpf4LI1WznPk",
        "colab_type": "text"
      },
      "source": [
        "Bilan :\n",
        "\n",
        "* la **parenthèse est parfois superflue** ; mais il se trouve qu'elle est **largement utilisée** pour améliorer la lisibilité des programmes,elle est **parfois nécessaire** selon l'endroit où le tuple apparaît dans le programme ;\n",
        "* la **dernière virgule est optionnelle** aussi, c'est le cas pour les tuples à au moins 2 éléments \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ql6bY5ASznPl",
        "colab_type": "text"
      },
      "source": [
        "### Conseil pour la présentation sur plusieurs lignes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lm82vBJzznPm",
        "colab_type": "text"
      },
      "source": [
        "En général d'ailleurs, la forme avec parenthèses et virgule terminale est plus pratique. Considérez par exemple l'initialisation suivante ; on veut créer un tuple qui contient des listes (naturellement un tuple peut contenir n'importe quel objet Python), et comme c'est assez long on préfère mettre un élément du tuple par ligne :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "34ArcZueznPm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mon_tuple = ([1, 2, 3],\n",
        "             [4, 5, 6],\n",
        "             [7, 8, 9],\n",
        "            )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PtU-Jgl7znPs",
        "colab_type": "text"
      },
      "source": [
        "L'avantage lorsqu'on choisit cette forme (avec parenthèses, et avec virgule terminale), c'est d'abord qu'il n'est pas nécessaire de mettre un backslash à la fin de chaque ligne ; parce que l'on est à l'intérieur d'une zone parenthésée, l'interpréteur Python \"sait\" que l'instruction n'est pas terminée et va se continuer sur la ligne suivante.\n",
        "\n",
        "Deuxièmement, si on doit ultérieurement ajouter ou enlever un élément dans le tuple, il suffira d'enlever ou d'ajouter toute une ligne, sans avoir à s'occuper des virgules ; si on avait choisi de ne pas faire figurer la virgule terminale, alors pour ajouter un élément dans le tuple après le dernier, il ne faut pas oublier d'ajouter une virgule à la ligne précédente. Cette simplicité se répercute au niveau du gestionnaire de code source, où les différences dans le code sont plus faciles à visualiser.\n",
        "\n",
        "Signalons enfin que ceci n'est pas propre aux tuples. La virgule terminale est également optionnelle pour les listes, ainsi d'ailleurs que pour tous les types Python où cela fait du sens, comme les dictionnaires et les ensembles que nous verrons bientôt. Et dans tous les cas où on opte pour une présentation multi-lignes, il est conseillé de faire figurer une virgule terminale."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmBaWwrSznPt",
        "colab_type": "text"
      },
      "source": [
        "### Tuples à un élément"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOjVIa8NznPv",
        "colab_type": "text"
      },
      "source": [
        "Pour revenir à présent sur le cas des tuples à un seul élément, c'est un cas particulier, parmi les quatre syntaxes que l'on a vues ci-dessus, on obtiendrait dans ce cas :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kpbC0DPvznPv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# ATTENTION : ces deux premières formes ne construisent pas un tuple !\n",
        "simple1 = 1\n",
        "simple2 = (1)\n",
        "# celles-ci par contre construisent bien un tuple\n",
        "simple3 = 1,\n",
        "simple4 = (1,)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOzXPwJBznP3",
        "colab_type": "text"
      },
      "source": [
        "* Il est bien évident que la première forme ne crée pas de tuple ;\n",
        "* et en fait la seconde non plus, car Python lit ceci comme une expression parenthésée, avec seulement un entier.\n",
        "\n",
        "Et en fait ces deux premières formes créent un entier simple :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HDtqEegCznP4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(simple2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TXcXRcljznP7",
        "colab_type": "text"
      },
      "source": [
        "Les deux autres formes créent par contre toutes les deux un tuple à un élément comme on cherchait à le faire :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iDrmc4o-znP8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(simple3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jMTlX0sFznQA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "simple3 == simple4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MP3OkiUVznQH",
        "colab_type": "text"
      },
      "source": [
        "Pour conclure, disons donc qu'il est conseillé de **toujours mentionner une virgule terminale** lorsqu'on construit des tuples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "23Sv2M3lznQI",
        "colab_type": "text"
      },
      "source": [
        "### Parenthèse parfois obligatoire"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfn21UjkznQK",
        "colab_type": "text"
      },
      "source": [
        "Dans certains cas vous vous apercevrez que la parenthèse est obligatoire. Par exemple on peut écrire :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f1aCdmKcznQL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = (1,)\n",
        "(1,) == x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mQu-OMXbznQP",
        "colab_type": "text"
      },
      "source": [
        "Mais si on essaie d'écrire le même test sans les parenthèses :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "latex:skip-eval": true,
        "id": "tjBlxZ-XznQP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# ceci provoque une SyntaxError\n",
        "1, == x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tEJqJsFqznQW",
        "colab_type": "text"
      },
      "source": [
        "Python lève une erreur de syntaxe ; encore une bonne raison pour utiliser les parenthèses."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "14BEbfXgznQY",
        "colab_type": "text"
      },
      "source": [
        "### Addition de tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7FPwbWGLznQZ",
        "colab_type": "text"
      },
      "source": [
        "Bien que le type tuple soit immuable, il est tout à fait légal d'additionner deux tuples, et l'addition va produire un **nouveau** tuple :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_91-jc6znQa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tuple1 = (1, 2,)\n",
        "tuple2 = (3, 4,)\n",
        "print('addition', tuple1 + tuple2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E2XBi_mPznQe",
        "colab_type": "text"
      },
      "source": [
        "Ainsi on peut également utiliser  l'opérateur `+=` avec un tuple qui va créer, comme précédemment, un nouvel objet tuple :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7A_oEwsyznQg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tuple1 = (1, 2,)\n",
        "tuple1 += (3, 4,)\n",
        "print('apres ajout', tuple1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9VS4Z_VznQn",
        "colab_type": "text"
      },
      "source": [
        "### Construire des tuples élaborés"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VgUZCq8JznQo",
        "colab_type": "text"
      },
      "source": [
        "Malgré la possibilité de procéder par additions successives, la construction d'un tuple peut s'avérer fastidieuse."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iHHRr0J-znQp",
        "colab_type": "text"
      },
      "source": [
        "Une astuce utile consiste à penser aux fonctions de conversion, pour construire un tuple à partir de - par exemple - une liste. Ainsi on peut faire par exemple ceci :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7fBDTjddznQp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# on fabrique une liste pas à pas\n",
        "liste = list(range(10))\n",
        "liste[9] = 'Inconnu'\n",
        "del liste [2:5]\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k94KpAUcznQt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# on convertit le résultat en tuple\n",
        "mon_tuple = tuple(liste)\n",
        "mon_tuple"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KPT_PcZe2ZSo",
        "colab_type": "text"
      },
      "source": [
        "### Tuples nommés\n",
        "\n",
        "Le p-uplet nommé consiste à accéder à un champ (un des objets du p-uplet) non par sa position mais par son nom.\n",
        "Le but est d’améliorer la lisibilité d’un programme.\n",
        "<BR><BR>\n",
        "*On souhaite créer un p-uplet nommé qui donne l’année de naissance, la ville de naissance et le pays de naissance d’une personne dont on connait le nom.*\n",
        "\n",
        "*On utilise l’outil Info=pupletnommé(‘Nom’, ‘annee ville pays’) pour créer autant d'objets du même type que l'on souhaite.*\n",
        "*Il faudra respecter cette notation.*\n",
        "*Ainsi Turing=Info(1912,Maida Vale, Royaume-Uni) crée un p-uplet nommé. Son nom est Turing.<BR>\n",
        "Pour récupérer le champ de l’année de naissance de Turing, il suffit de taper Turing.annee.<BR>\n",
        "De la même manière, Turing.pays retournera Royaume-Uni.*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jscA-Jat4Gfg",
        "colab_type": "text"
      },
      "source": [
        "*Exemple : <BR> Exécuter le code ci-dessous qui va créer le p-uplet nommé Info qui contiendra pour chaque nom les champs annee, etude et pays*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qvZ2wQKz3gc4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from collections import namedtuple\n",
        "Info=namedtuple('Nom','annee etude pays')\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GsOhmPSN4bc7",
        "colab_type": "text"
      },
      "source": [
        "Créer les informaticiens suivants en complétant la cellule de code ci-dessus: \n",
        "\n",
        "\n",
        "*   Charles_Babbage=Info(1791,'machines','Royaume-Uni')\n",
        "*   Heddy_Lamarr=Info(1914,'machines','Autriche')\n",
        "*   Rose_Dieng-Kuntz=Info(1956,'intelligence artificielle','Sénégal')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pvl2wX1g5PSD",
        "colab_type": "text"
      },
      "source": [
        "Ainsi, pour récupérer l’année de naissance de Shafi_Goldwasser, il suffit de taper : Shafi_Goldwasser.annee <BR>\n",
        "A vous de trouver 3 autre informaticiens ou informaticiennes célèbres avec les champs correspondants.<BR>\n",
        "Rajoutez les dans la ligne de code ci-dessus.<BR>\n",
        "Compléter ensuite pour faire afficher toutes les années."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YnfLthdv5J6Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}