Les_ensembles.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Les ensembles.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPGjMhKGI1FFz5AKR7EF/ub",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GeoLabUniLaSalle/Python/blob/main/Les_ensembles.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QUcOzyFje1Ys"
      },
      "source": [
        "## **Les ensembles**\n",
        "\n",
        "Dans ce chapitre, nous allons étudier le fonctionnement des ensembles.\n",
        "\n",
        "Commençons par créer un ensemble grâce au symbole {} qui est associé à ce type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SAzy9lEeewc_",
        "outputId": "827f0d97-bd79-45de-8d75-41d2ab2cabcb"
      },
      "source": [
        "ens = {8, 4, 11, 4, 7, 11, 4}\n",
        "print(type(ens))\n",
        "print(len(ens))\n",
        "print(ens)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "{8, 11, 4, 7}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0sgamfyUe1av"
      },
      "source": [
        "Notons que si un élément est présent plusieurs fois dans un ensemble, **une seule occurence est conservée**. Ici, cet ensemble contient 4 éléments uniques.\n",
        "\n",
        "Notons également qu'il n'y a **pas de notion d'ordre** dans un ensemble. Il est impossible d'accéder au contenu par un indice :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "8LZpK6RRfq4r",
        "outputId": "1b67c348-874c-4804-ddc6-ddecb58adf76"
      },
      "source": [
        "ens[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-84cabad8e845>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mens\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NaBl8CZnf96o"
      },
      "source": [
        "Les éléments qui composent un ensemble peuvent être **hétérogènes**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sp4-Di8-f8Ko"
      },
      "source": [
        "ens2 = {\"Hello\", 42, True, (1, 2, 3), 5.74}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zscBYss3gdOO"
      },
      "source": [
        "Attention cependant : un ensemble ne peut contenir que des variables de type primitif (int, float, bool) ou des séquences **immuables** (str, tuple), mais pas de séquences **mutables** (list, dict)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "AMGPjaw2iion",
        "outputId": "49af5777-3186-4475-8272-9d04c190df84"
      },
      "source": [
        "ens3 = {\"Hello\", 42, True, (1, 2, 3), 5.74, [1, 2, 3]}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-ea16e5116cb9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mens3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"Hello\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m42\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5.74\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orUkVGakjFSA"
      },
      "source": [
        "Il est facilement possible de rechercher si un élément est présent *dans* un ensemble avec l'opérateur in."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-aDDUwjXjEWR",
        "outputId": "217749ef-f260-4641-f434-627ae4485b27"
      },
      "source": [
        "42 in ens2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AKo4VSEcjeFr"
      },
      "source": [
        "Nous pouvons aussi parcourir des ensembles avec un *for*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "re4yxV1WjVl6",
        "outputId": "02295516-c18a-403f-fa7a-2c047cff1b31"
      },
      "source": [
        "for i in ens2:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "5.74\n",
            "42\n",
            "(1, 2, 3)\n",
            "Hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N_yFlbOOjoJH"
      },
      "source": [
        "Pour créer un ensemble vide ou un ensemble à partir d'un str, nous pouvons utiliser la fonction *set*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UTeV3ljIjlBT",
        "outputId": "632d12a1-dc5c-48d3-85ee-ac5f290e64c7"
      },
      "source": [
        "vide = set()\n",
        "print(vide)\n",
        "\n",
        "a = set('bonjour')\n",
        "print(a)\n",
        "\n",
        "b = set('bonhomme')\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "set()\n",
            "{'j', 'n', 'o', 'b', 'u', 'r'}\n",
            "{'m', 'e', 'n', 'o', 'b', 'h'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uynQRsj7kI1Y"
      },
      "source": [
        "Nous remarquons que les lettres qui composent 'bonjour' et 'bonhomme' sont placées dans un ordre imprévisible, et que les lettres en doublon sont supprimés.\n",
        "\n",
        "Voici les principaux opérateurs dédiés aux ensembles."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WKwo0AvDkELp",
        "outputId": "f52420a0-4edf-4ca3-b81d-ac4e30d2eebc"
      },
      "source": [
        "print(a - b) # Différence - Elements présents dans a mais pas dans b\n",
        "print(b - a) # Différence - Elements présents dans b mais pas dans a\n",
        "print(a | b) # Union - Elements présents dans a ou b\n",
        "print(a & b) # Intersection - Elements présents dans a et b\n",
        "print(a ^ b) # Différence symétrique - Elements présents dans un ensemble mais pas dans l'autre"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'u', 'r'}\n",
            "{'h', 'm', 'e'}\n",
            "{'j', 'm', 'e', 'n', 'o', 'b', 'h', 'u', 'r'}\n",
            "{'n', 'o', 'b'}\n",
            "{'j', 'm', 'h', 'e', 'u', 'r'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YWHrZL2NmEF8"
      },
      "source": [
        "Il est possible de réaliser une assignation en utilisant ces opérateurs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0oSNuy8bmIFJ",
        "outputId": "cd3f2dee-bed0-4768-ebae-fa56f35c0d81"
      },
      "source": [
        "a|={'z'} # a = a | 'z' - a reçoit l'Union de a et de 'z'\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'z', 'o', 'b', 'x', 'u', 'r'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UZYHZAWMmWSf",
        "outputId": "76cf700d-7c4d-4ab4-99c5-9a2bab154971"
      },
      "source": [
        "a-={'o','u','r'} # a = a - {'o','u','r'} - a reçoit la Différence de a et {'o','u','r'}\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'z', 'b', 'x'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IhhjtVLtlSU6"
      },
      "source": [
        "Il est possible d'ajouter ou de supprimer un élément d'un ensemble par les méthodes *add* et *remove*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lGObQiWckbXB",
        "outputId": "ead0193c-1d8a-4191-e141-edd8fbedca44"
      },
      "source": [
        "print(a)\n",
        "a.add('x')\n",
        "print(a)\n",
        "a.remove('n')\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'n', 'o', 'b', 'x', 'u', 'r'}\n",
            "{'j', 'n', 'o', 'b', 'x', 'u', 'r'}\n",
            "{'j', 'o', 'b', 'x', 'u', 'r'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lcuj4JhYljZa"
      },
      "source": [
        "La méthode *remove* donne un message d'erreur si l'on essaie de supprimer un élément qui ne figure pas dans l'ensemble. Pour éviter ce message d'erreur, nous pouvons utiliser la méthode *discard*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "5T9fxJrZl5Nq",
        "outputId": "da86442a-650d-41b0-8c2f-3c9880367a92"
      },
      "source": [
        "a.remove('y')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-42e5f0c61f9a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'y'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'y'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QZLf3Pb_l7TJ",
        "outputId": "0fec5700-3a0e-4613-b2f6-85be79b82fe9"
      },
      "source": [
        "a.discard('y')\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'o', 'b', 'x', 'u', 'r'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3LmWzNZomtWa"
      },
      "source": [
        "La méthode *pop* est disponible sur les ensembles."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gufes_swl9k7",
        "outputId": "b2b97eec-a78d-44e8-ec54-8ea8893c24ed"
      },
      "source": [
        "print(a)\n",
        "print(a.pop())\n",
        "print(a)\n",
        "print(a.pop())\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'z', 'b', 'x'}\n",
            "j\n",
            "{'z', 'b', 'x'}\n",
            "z\n",
            "{'b', 'x'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I23Dy4-bm8O_"
      },
      "source": [
        "Il est possible de vider un ensemble grâce à la méthode *clear*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CS9IqHkfm_NY",
        "outputId": "d9e4d810-7917-4def-a847-46eac5b68476"
      },
      "source": [
        "a.clear()\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "set()\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O3wQDO-InJjK"
      },
      "source": [
        "Enfin, nous pouvons employer les opérateurs relationnels."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I4jbswPKm3OY",
        "outputId": "e644f1ba-13bf-47fa-b79d-90e678fcfa6d"
      },
      "source": [
        "a = set('bonjour')\n",
        "b = set('bruno')\n",
        "print(a)\n",
        "print(b)\n",
        "print(a<b) # a inclu dans b\n",
        "print(b<=a) # b inclu ou égal à a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'j', 'n', 'o', 'b', 'u', 'r'}\n",
            "{'n', 'o', 'b', 'u', 'r'}\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}