Ch1_Notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ch1_Notebook.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "hFQa64ujALty",
        "XlA85hOUL3wf",
        "d5WBpUDI9YOA",
        "xI4Nzuhg0uAd",
        "s4Cos-9BIFCy",
        "6wh58qRFFN7M",
        "l-f9Rp5aI_6y",
        "QzzQEmelzOY7",
        "wJChq_naMsOA",
        "cDQhvM22Zwvp"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNRj+Rv+F2p7bCf+NEb32gh",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/othoni-hub/ECG1/blob/main/Ch1_Notebook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9gRjJPolrmT_"
      },
      "source": [
        "# **CPGE-ECG1** \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gprox7oVPE7W"
      },
      "source": [
        "\n",
        "\n",
        "## **Ch1 - Notebook : Logique**\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?id=12Wo3LubGGT4qOvYFAuLP4CyCuwjKNVuk\" width=\"230\" height=\"150\" align = \"right\"/>\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "**O.Thöni - Lycée Saint-Charles Sainte Croix - LE MANS**\n",
        "\n",
        "[>>NoteBook complété<<](https://colab.research.google.com/drive/1R1ZlMqFY5aFP1g5VosOJKaUzkXxbLq-l?usp=sharing)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zf_7dFWYrCpO"
      },
      "source": [
        "Aucune notion de ce notebook n'est exigible, mais il permet d'entraîner la réflexion algorithmique et le travail autour des ensembles.\n",
        "\n",
        "**Sauf toutefois, à mémoriser :**\n",
        "* | (\"ou\")\n",
        "* & (\"et\")\n",
        "* les \"dictionnaires\" (***dict***) et la liste de leurs clés et de leurs valeurs (***.keys()*** et ***.values()***)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ICIVhirAsBpr"
      },
      "source": [
        "# **1. Ensembles**\n",
        "\n",
        "Python dispose d'un type de variables nommé ***set***, qui, comme sont nom l'indique, permet de modéliser très exactement la notion mathématique d'**ensembles**.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Un *set*  s'écrit entre accolades, les éléments étant séparés par des vuigules, et le type dispose de \"méthodes\", c'est-à-dire de fonctions intrinsèques associées, et d'opérateurs qui sont les mêmes qu'en mathématiques : intersection, union, etc.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPsSTFK_u8Ze"
      },
      "source": [
        "A = {2,5,3,2,6,8,7,10}\n",
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4OC_h7kNO_OT"
      },
      "source": [
        "type(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-bTtNGwC-nc"
      },
      "source": [
        "Observer ce qu'il est advenu des doublons, et de l'ordre des éléments... :*\n",
        "\n",
        "**Un ensemble contient des éléments distincts, Python retire les doublons, \n",
        "Python range les éléments dans l'ordre alphabétique, mais l'ordre des éléments dans un ensemble n'a pas d'importance :**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKTer6-_z3cO"
      },
      "source": [
        "{1,2,3}=={2,3,1}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_IrBpp-z-ty"
      },
      "source": [
        "{1,2,3}=={1,1,2,3}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NlDfjE2uw78R"
      },
      "source": [
        "## **Cardinal**\n",
        "\n",
        "Le nombre d'éléments de l'ensemble A est donné par :\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bmwia188vmKl"
      },
      "source": [
        "len(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QLsgMuiLxNk5"
      },
      "source": [
        "## **Transformation d'une variable en *set* (\"transtypage\")**\n",
        "\n",
        " Un *set* peut être défini à partir d'une variable d'un autre type, par exemple ici, un \"*range*\", puis une liste définie par compréhension :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RAKlvsDexASF"
      },
      "source": [
        "B = set(range(2,12,2)) #ensemble des nombres entiers, de 2 en 2, de 2 inclus à 12 exclu\n",
        "B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6BC1H3KMxgTx"
      },
      "source": [
        "C = set([2*i for i in range(1,6)]) # ensemble des 5 premiers nombres pairs non nuls\n",
        "C"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-NzhA23Fzf8p"
      },
      "source": [
        "##  **Test d'appartenance**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6F6sNsnLysXs"
      },
      "source": [
        "3 in A # booléen qui vaut vrai si 3 appartient à A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w3exsg0WzqG7"
      },
      "source": [
        "3 in B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kiEEtjlsHcjJ"
      },
      "source": [
        "3 not in B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hFQa64ujALty"
      },
      "source": [
        "## **Fabriquer un ensemble vide**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z2cSR4PMARX2"
      },
      "source": [
        "V = set()\n",
        "V"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XlA85hOUL3wf"
      },
      "source": [
        "## **Dupliquer un *set***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ZLf0XmYL8Zu"
      },
      "source": [
        "G = A.copy()\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d5WBpUDI9YOA"
      },
      "source": [
        "## **Ajout/retrait d'un élément connu/retrait d'un élément non prédéfini**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5R1iF8t9fBX"
      },
      "source": [
        "A.add(9)        # \"méthode\" qui ajoute l'élément 9 à l'ensemble A, s'il n'y est déjà\n",
        "A.discard(8)    # \"méthode\" qui retire l'élément 8 de A s'il y figure\n",
        "                # il existe aussi la méthode remove, mais elle provoque une erreur si l'élément est absent\n",
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K4efBG6WIzXX"
      },
      "source": [
        "A.pop() # .pop() retire le 1er élément par ordre alphabétique\n",
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H2008FlWJNdX"
      },
      "source": [
        "# **2. Opérations sur les ensembles**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xI4Nzuhg0uAd"
      },
      "source": [
        "## **Fonctions \"réunion\", \"intersection\", différence\", \"différence réciproque\"**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s4Cos-9BIFCy"
      },
      "source": [
        "### **--> algorithmiquement**\n",
        "\n",
        "En utilisant les méthodes .copy(), .add() et .pop(), écrire les fonctions spécifiées ci-dessous...\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ponfexPiKxz8"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0DSkRQsvLB7m"
      },
      "source": [
        "B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IlIpZZyfjqxy"
      },
      "source": [
        "* **intersection**\n",
        "\n",
        "<img src=\"https://cdn.programiz.com/sites/tutorial2program/files/set-intersection.jpg\" width=\"175\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YrqBD3CbApBX"
      },
      "source": [
        "def intersection(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble I égal à leur intersection.'''\n",
        "    C = E.copy() # C est une copie de E, sans cela, l'ensemble entrant dans la fonction serait modifié dans le programme principal\n",
        "                 # C est une variable locale. Si une variable porte le même nom dans le programme principal, elle ne sera pas modifiée\n",
        "    I = set()\n",
        "    while len(C)>0:    # tant que D n'est pas vide\n",
        "        element = C.pop()  # on retire un élément indéterminé de D\n",
        "        if element in F :  # on regarde s'il est dans F\n",
        "            I.add(element) # si oui, on l'ajoute à l'ensemble intersection\n",
        "    return I\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xhI1YZjErcJ"
      },
      "source": [
        "# Test\n",
        "G = intersection(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BO-dd7uUK0oo"
      },
      "source": [
        "A # A ne devrait pas être modifié, c'est grâce au .copy() dans la fonction intersection"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cmrAeTD7NfKF"
      },
      "source": [
        "C # Dans la fonction, la variable C était locale, le contenu de la variable globale C n'a pas été modifié"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XUDPKRNCs829"
      },
      "source": [
        "**observation du déroulement de la fonction dans Python Tutor**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxKd1SkjtEw1"
      },
      "source": [
        "!pip install metakernel\n",
        "\n",
        "from metakernel import register_ipython_magics\n",
        "register_ipython_magics()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nh3ndzk_tQJZ"
      },
      "source": [
        "%%tutor # lancement de PythonTutor\n",
        "\n",
        "def intersection(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble I égal à leur intersection.'''\n",
        "    C = E.copy() # C est une copie de E, sans cela, l'ensemble entrant dans la fonction serait modifié dans le programme principal\n",
        "                 # C est une variable locale. Si une variable porte le même nom dans le programme principal, elle ne sera pas modifiée\n",
        "    I = set()\n",
        "    while len(C)>0:    # tant que D n'est pas vide\n",
        "        element = C.pop()  # on retire un élément indéterminé de D\n",
        "        if element in F :  # on regarde s'il est dans F\n",
        "            I.add(element) # si oui, on l'ajoute à l'ensemble intersection\n",
        "    return I\n",
        "\n",
        "A = {5,3,6,9,7,10}\n",
        "B = set(range(2,12,2))\n",
        "\n",
        "G = intersection(A,B)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H99_BzTqx9Ti"
      },
      "source": [
        "**itération sur un ensemble**\n",
        "\n",
        "Plus simplement que ci-dessus, un ensemble Python est dit **\"itérable\"**, c'est-à-dire que l'on peut construire une boucle ***for*** directement sur ses éléments :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pibw2FFNx8q0"
      },
      "source": [
        "def intersection(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble I égal à leur intersection.'''\n",
        "    \n",
        "    I = set()\n",
        "    for element in E : # Pour chaque éléments de E...\n",
        "                           # on regarde s'il est dans F\n",
        "                           # si oui, on l'ajoute à l'ensemble intersection\n",
        "    return I\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FKY4vC56ykdO"
      },
      "source": [
        "# Test\n",
        "G = intersection(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSIPL85ByqvC"
      },
      "source": [
        "**observation dans Python Tutor**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "swkofPIfytw1"
      },
      "source": [
        "%%tutor # lancement de PythonTutor\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "A = {5,3,6,9,7,10}\n",
        "B = set(range(2,12,2))\n",
        "\n",
        "G = intersection(A,B)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vsCukDfBkM3D"
      },
      "source": [
        "* **union**\n",
        "\n",
        "<img src=\"https://cdn.programiz.com/sites/tutorial2program/files/set-union.jpg\" width=\"175\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X3ZMQchl1Io6"
      },
      "source": [
        "def reunion(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble U égal à leur réunion.'''\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MaRsiinvE5fS"
      },
      "source": [
        "# Test\n",
        "G = reunion(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MVcWELclkaJG"
      },
      "source": [
        "* **différence**\n",
        "\n",
        "<img src=\"https://cdn.programiz.com/sites/tutorial2program/files/set-difference.jpg\" width=\"175\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_GcnQzUnDyEo"
      },
      "source": [
        "def difference(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble D égal à leur différence, \n",
        "    c'est-à-dire l'ensemble des éléments de E qui ne sont pas dans F.'''\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ReMHrwSjFC7F"
      },
      "source": [
        "# Test\n",
        "G = difference(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uIQW9OWhk129"
      },
      "source": [
        "* **différence réciproque**\n",
        "\n",
        "<img src=\"https://cdn.programiz.com/sites/tutorial2program/files/set-symmetric-difference.jpg\" width=\"175\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zkt2M9iZGnk7"
      },
      "source": [
        "def difference_reciproque(E,F):\n",
        "    ''' Cette fonction reçoit deux ensembles E et F et renvoie l'ensemble D égal à leur différence réciproque, \n",
        "    c'est-à-dire l'ensemble des éléments de E qui ne sont pas dans F et des éléments de F qui ne sont pas dans E.'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zfe98YFaHAvM"
      },
      "source": [
        "# Test\n",
        "G = difference_reciproque(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wh58qRFFN7M"
      },
      "source": [
        "### **--> fonctions prédéfinies**\n",
        "\n",
        "Les fonctions précédentes existent évidemment déjà nativement dans Python..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fzKdEgFUHOzf"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1qdnAu7JHQYT"
      },
      "source": [
        "B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hKsvhcStHVq7"
      },
      "source": [
        "* **union**\n",
        "\n",
        "En Python, le symbole opératoire de l'union est le \" **|** \" qui signifie **\"ou\"**. \n",
        "\n",
        "**Et ça, c'est à retenir !**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjut5varFYYH"
      },
      "source": [
        "U = A | B\n",
        "U"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rRgTjFDYFnVB"
      },
      "source": [
        "* **intersection**\n",
        "\n",
        "En Python, le symbole opératoire de l'intersection est le \" **&** \" qui signifie **\"et\"**.\n",
        "\n",
        "**Et ça, c'est à retenir !**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VHKzX4tMFpWY"
      },
      "source": [
        "I = A & B\n",
        "I"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9sGbzuDnFwEj"
      },
      "source": [
        "* **différence**\n",
        "\n",
        "En Python, le symbole opératoire de la différence est le \" **-** \", tout simplement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2VMhF6_2FyZE"
      },
      "source": [
        "D = A - B\n",
        "D"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yD2RXeEHD9H"
      },
      "source": [
        "* **différence réciproque**\n",
        "\n",
        "En Python, le symbole opératoire de la différence réciproque est le \" **^** \"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c59Vqor9HHaw"
      },
      "source": [
        "DR = A ^ B\n",
        "DR"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l-f9Rp5aI_6y"
      },
      "source": [
        "## **Produit cartésien de deux ensembles**\n",
        "\n",
        "Rappel : le produit cartésien de deux ensembles E et F est l'ensemble des couples constitués d'un élément de E et d'un élément de F (dans cet ordre)\n",
        "\n",
        "Le **couple** est un type qui existe en Python (dans la famille des ***tuples***, ou **p-uplets** en français)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VZDWsaxiKCQ9"
      },
      "source": [
        "def produit_cartesien(E,F):\n",
        "    '''Fonction qui reçoit deux ensembles en entrée et renvoie leur produit cartésien P, \n",
        "    ensemble des couples constitués d'un élément de E et d'un élément de F.'''\n",
        "    P = set()\n",
        "\n",
        "    for element_de_E in E :\n",
        "        for element_de_F in F :\n",
        "            nouveau_couple = (element_de_E,element_de_F)    # chaque couple a pour 1ère composante l'élément de E \n",
        "                                                            # et pour 2ème composante l'élément de F\n",
        "            P = P | {nouveau_couple} # on ajoute le nouveau couple au produit cartésien\n",
        "    return P\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CwiM4mQqKr-S"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8L-nDiuYKwMp"
      },
      "source": [
        "B"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dx-jO5dnKxXD"
      },
      "source": [
        "G = produit_cartesien(A,B)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xMUXX_cnLHMv"
      },
      "source": [
        "len(G) == len(A)*len(B)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QzzQEmelzOY7"
      },
      "source": [
        "## **Comparaison d'ensembles**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wJChq_naMsOA"
      },
      "source": [
        "### **inclusion**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cME_lzNAMvon"
      },
      "source": [
        "def Est_Inclus_Dans(E,F) :\n",
        "    '''fonction qui reçoit deux ensemble E et F et renvoie vrai si E est inclus dans F'''\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fi21Iq8ONTQq"
      },
      "source": [
        "# Test\n",
        "H = {1,3,5}\n",
        "D = set(range(7))\n",
        "\n",
        "Est_Inclus_Dans(H,D)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cZZDFYjnN3hi"
      },
      "source": [
        "**opérateur Python prédéfini :**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3fww5dLeN8fU"
      },
      "source": [
        "C <= D"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ikTbxsNfOVx3"
      },
      "source": [
        "**test d'égalité**\n",
        "\n",
        "avec notre fonction, double-inclusion :\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAJyGrO3OhbG"
      },
      "source": [
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hAoxCXZ2O-Mz"
      },
      "source": [
        "ou plus simplement :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FGDtCz62yZtg"
      },
      "source": [
        "B == C"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ueq6Wq0f0XQb"
      },
      "source": [
        "# **3. Ensemble des parties d'un ensemble**\n",
        "\n",
        "Ici, petit problème, il est impossible, en Python, de constituer des *sets* de *sets*. Nous allons donc travailler avec une liste de *sets*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QpF4jNOq1IBx"
      },
      "source": [
        "def Ensemble_des_Parties(E):\n",
        "    '''Fonction qui reçoit un ensemble E en paramètre et renvoie l'ensemble P de ses parties'''\n",
        "    \n",
        "    P = [set()] # On initialise le résultat à la liste qui ne contient que l'ensemble vide\n",
        "    for element in E:               # Pour chaque élément de E\n",
        "        liste_ajouts = []                   # on va fabriquer une nouvellle liste de parties en ajoutant ce nouvel élément à chaque partie déjà existante\n",
        "        for partie in P :                   # Pour chaque partie existante, \n",
        "            liste_ajouts.append(partie | {element}) # on ajoute l'élément à chaque partie existante, on crée ainsi une nouvelle partie\n",
        "                                                    # qu'on ajoute à la liste d'ajouts\n",
        "        P = P + liste_ajouts                # on fusionne l'ancienne liste avec la nouvelle, la taille double donc à chaque itération\n",
        "    return P\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oYyoWfw2fsn"
      },
      "source": [
        "# test\n",
        "D = {1,2,3}\n",
        "G = Ensemble_des_Parties(D)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yZyq6a6MA8vm"
      },
      "source": [
        "len(G) == 2**len(D) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1fgQu6r7Hw-B"
      },
      "source": [
        "%%tutor # lancement de PythonTutor\n",
        "\n",
        "def Ensemble_des_Parties(E):\n",
        "    '''Fonction qui reçoit un ensemble E en paramètre et renvoie l'ensemble P de ses parties'''\n",
        "    \n",
        "    P = [set()] # On initialise le résultat à la liste qui ne contient que l'ensemble vide\n",
        "    for element in E:               # Pour chaque élément de E\n",
        "        liste_ajouts = []                   # on va fabriquer une nouvellle liste de parties en ajoutant ce nouvel élément à chaque partie déjà existante\n",
        "        for partie in P :                   # Pour chaque partie existante, \n",
        "            liste_ajouts.append(partie | {element}) # on ajoute l'élément à chaque partie existante, on crée ainsi une nouvelle partie\n",
        "                                                    # qu'on ajoute à la liste d'ajouts\n",
        "        P = P + liste_ajouts                # on fusionne l'ancienne liste avec la nouvelle, la taille double donc à chaque itération\n",
        "    return P\n",
        "\n",
        "# test\n",
        "D = {1,2,3}\n",
        "G = Ensemble_des_Parties(D)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6wikqL8r6Ph"
      },
      "source": [
        "# **4. Applications sur des ensembles finis**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cDQhvM22Zwvp"
      },
      "source": [
        "## **Modélisation d'une application par un dictionnaire**\n",
        "\n",
        "**Rappel :**\n",
        "\n",
        "**Si E et F sont deux ensembles ayant chacun un nombre fini d'éléments, définir une application de E dans F consiste à mettre en correspondance, pour chaque élément de E, un élément de F et un seul.**\n",
        "\n",
        "Un outil adapté pour modéliser une application dans Python est le **dictionnaire (*dict*)**.\n",
        "Un dictionnaire Python va permettre de rassembler des éléments identifiés, non plus par leur position comme dans une liste, mais par une **clé** (***key*** en anglais). À chaque clé est associée une **valeur** (***value***) en anglais (qui peut elle-même être, pourquoi pas, d'un type construit, comme une liste ou un autre dictionnaire).\n",
        "\n",
        "Cette \"association\" est exactement ce qu'il nous faut pour définir une application (\"l'application f qui a x **associe** y = f(x)\").\n",
        "\n",
        "Par exemple, si E est l'ensemble des entiers de 1 à 12 et F celui des entiers de 1 à 6,\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M_y0vQEecLWy"
      },
      "source": [
        "E = {1,2,3,4,5,6,7,8,9,10} # ou E = range(1,11)\n",
        "F = {1,2,3,4,5,6}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oXHZXJ5icvKv"
      },
      "source": [
        "... on peut définir l'application f, qui, à chaque élément x de E associe l'élément y de F égal au nombre de diviseurs de x...\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yGJShEJVdgm2"
      },
      "source": [
        "<img src=\"https://drive.google.com/uc?id=12xC4OgFZuJYB2VP-0uuD5icisCFb5tLk\" width=\"400\" height=\"400\" align =  \"right\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sIX8GWI6k9aG"
      },
      "source": [
        "**Rappel vocabulaire :**\n",
        "\n",
        "* 6 a pour **image** 4\n",
        "* 4 est l'image de 6\n",
        "* 4 a pour **antécédents** 6, 8, et 10\n",
        "* l'**ensemble-image** de l'application f, noté $Im(f)$ est l'ensemble des éléments de F qui ont au moins un antécédent par f, ici, $Im(f) = \\{1,2,3,4,6\\}$\n",
        "* Si tout élément de F possède **au plus** un antécédent par f, on dit que f est une application **injective**\n",
        "* Si tout élément de F possède **au moins** un antécédent par f, on dit que f est une application **surjective**\n",
        "* Si tout élément de F possède **exactement** un antécédent par f, on dit que f est une application **bijective**\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5-yzB-LHmoPF"
      },
      "source": [
        "Le **graphe** de notre application f, c'est-à-dire l'ensemble de toutes les associations d'un élément de E avec un élément unique de F, peut alors être **modélisée** par le **dictionnaire** suivant :\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a5IvoWHycoMQ"
      },
      "source": [
        "f = { 1: 1 , 2: 2 , 3: 2 , 4: 3 , 5: 2 , 6: 4 , 7: 2 , 8: 4 , 9: 3 , 10: 4 , 11: 2 , 12: 6 }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CsDamztpuRPn"
      },
      "source": [
        "... car 1 a 1 diviseur, 4 en a 3, 10 en a 4 et 12 en a 6, etc.\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3KjRB-oPnIu7"
      },
      "source": [
        "**À retenir :**\n",
        "\n",
        "Comme on le voit, **un dictionnaire est délimité entre accolades, chaque \"entrée\" (élément) est définie par sa clé**, ici chaque élément de E, **suivie de \":\", puis la valeur associée à cette clé,** ici, le nombre de diviseurs de la clé, c'est donc un nombre de F, **les \"entrées\" sont séparées par des virgules.**\n",
        "\n",
        "La liste des clés peut être obtenue pas la méthode **\".keys()\"**,\n",
        "\n",
        "La liste des valeurs, par la méthode **.values()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pk5IyrISp91Y"
      },
      "source": [
        "f.keys()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f8idHhGlqKTc"
      },
      "source": [
        "f.values()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vKXzBDcyskl3"
      },
      "source": [
        "On accède à un élément par sa clé : (attention, entre crochets)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U0-qHvc1spdT"
      },
      "source": [
        "f[12] # valeur associée à la clé 12 dans le dictionnaire f"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3B0FYYx7m5qv"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Compléter les fonctions ainsi spécifiées ci-dessous :\n",
        "\n",
        "**Remarque :**\n",
        "\n",
        "Les clés étant regroupées dans une liste, on peut itérer sur la liste des clés :\n",
        "\n",
        "--> *for bidule in f.keys(): # pour chaque clé dans la liste des clés, faire...*\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qwB8Xv7YnCQR"
      },
      "source": [
        "def Im(f) : \n",
        "    '''Fonction qui reçoit en entrée un dictionnaire qui modélise le graphe d'une application f et qui retourne l'ensemble-image de f'''\n",
        "\n",
        "\n",
        "def EstSurjective(f):\n",
        "    '''Fonction qui reçoit en entrée le graphe d'une application f modélisé par un dictionnaire\n",
        "    et qui retourne vrai si l'application est surjective'''\n",
        "\n",
        "\n",
        "\n",
        "def EstInjective(f):\n",
        "    '''Fonction qui reçoit en entrée le graphe d'une application f modélisé par un dictionnaire\n",
        "    et qui retourne vrai si l'application est injective'''\n",
        "\n",
        "\n",
        "\n",
        "def EstBijective(f):\n",
        "    '''Fonction qui reçoit en entrée le graphe d'une application f modélisé par un dictionnaire\n",
        "    et qui retourne vrai si l'application est bijective'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K795r2Yzucxb"
      },
      "source": [
        "G = Im(f)\n",
        "G"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TWLnWdrBujBZ"
      },
      "source": [
        "EstSurjective(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XyP8rBgGuoxi"
      },
      "source": [
        "EstInjective(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9j1_6_EuuS3"
      },
      "source": [
        "EstBijective(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U2RhyYavu2lG"
      },
      "source": [
        "## **Composition des applications**\n",
        "\n",
        "**Rappel :**\n",
        "si  est une application de E vers F, qui à un élément x de E associe l'élément y = f(x),\n",
        "\n",
        "et si g est une application de F vers G, qui, à un élément y de F associe l'élément z = g(y) dans G, \n",
        "\n",
        "alors l'application, de E vers G qui à x associe z = g(f(x)) est appelée l'**\"application composée de f suivie de g\", notée g o f** \n",
        "\n",
        "--> attention à l'ordre : g o f car (g o f)(x) = g(f(x))\n",
        "\n",
        "c'est bien f qui est appliquée d'abord, puis g\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_mPMOcOkwVF5"
      },
      "source": [
        "Écrire la fonction suivante, qui étant donnés les graphes de f et g, calcule celui de g o f :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vuTC_Uzjux7M"
      },
      "source": [
        "def composee(f,g) : \n",
        "    '''Cette fonction reçoit les graphes de deux applications f et g, modélisés par des dictionnaires,\n",
        "    elle doit vérifier que les valeurs de l'image de f sont bien dans l'ensemble des clés de g\n",
        "    puis renvoie le graphe de g o f'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tedLHzbGxkHN"
      },
      "source": [
        "# Test\n",
        "f = { 1: 1 , 2: 2 , 3: 2 , 4: 3 , 5: 2 , 6: 4 , 7: 2 , 8: 4 , 9: 3 , 10: 4 , 11: 2 , 12: 6 }\n",
        "g = { 1 : \"pas premier\" , 2 : \"premier\" , 3 : \"carré\", 4 : \"pas premier\", 5 : \"carré\", 6 : \"pas premier\"}\n",
        "\n",
        "h = composee(f,g)\n",
        "h"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BqlUikU6yJYA"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}