{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden"
   },
   "source": [
    "[prev: Le retour des fonctions](function-arguments.ipynb) | [home](../index.ipynb) | [next: Bien boucler en Python](loop-pythonic.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utilisation avancée des conteneurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un conteneur de plus : `set`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un set est non ordonné et ne contient qu'une seule occurrence de chacun de ses éléments (non duplication)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3.14, 'toto'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# construction littéral\n",
    "{1, 2, 'toto', 2, 3.14}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérations d'ensembles sont disponibles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# union\n",
    "{2, 3, 4} | {1, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# intersection\n",
    "{2, 3, 4} & {1, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# différence\n",
    "{2, 3, 4} - {1, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# différence symétrique\n",
    "{2, 3, 4} ^ {1, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# une manière d'enlever les doublons d'une liste\n",
    "l = [1, 2, 3, 2, 4, 1, 4]\n",
    "set(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les méthodes des conteneurs de base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_methodes(type1, type2):\n",
    "    build_attr = lambda type_: set(e for e in dir(type_) if e[0] != '_')\n",
    "    attr1 = build_attr(type1)\n",
    "    attr2 = build_attr(type2)\n",
    "\n",
    "    print(f'* méthodes communes à {type1.__name__} et {type2.__name__}:')\n",
    "    print(list(attr1 & attr2))\n",
    "    print()\n",
    "    print(f'* méthodes propres à {type1.__name__} :')\n",
    "    print(list(attr1 - attr2))\n",
    "    print()\n",
    "    print(f'* méthodes propres à {type2.__name__} :')\n",
    "    print(list(attr2 - attr1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list vs tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* méthodes communes à list et tuple:\n",
      "['count', 'index']\n",
      "\n",
      "* méthodes propres à list :\n",
      "['pop', 'append', 'extend', 'sort', 'remove', 'copy', 'reverse', 'insert', 'clear']\n",
      "\n",
      "* méthodes propres à tuple :\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "compare_methodes(list, tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "append(self, object, /)\n",
      "    Append object to the end of the list.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.append)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "extend(self, iterable, /)\n",
      "    Extend list by appending elements from the iterable.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.extend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list vs dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* méthodes communes à list et dict:\n",
      "['pop', 'clear', 'copy']\n",
      "\n",
      "* méthodes propres à list :\n",
      "['append', 'index', 'extend', 'sort', 'remove', 'count', 'reverse', 'insert']\n",
      "\n",
      "* méthodes propres à dict :\n",
      "['values', 'get', 'items', 'keys', 'fromkeys', 'setdefault', 'popitem', 'update']\n"
     ]
    }
   ],
   "source": [
    "compare_methodes(list, dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "get(self, key, default=None, /)\n",
      "    Return the value for key if key is in the dictionary, else default.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(dict.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "setdefault(self, key, default=None, /)\n",
      "    Insert key with a value of default if key is not in the dictionary.\n",
      "    \n",
      "    Return the value for key if key is in the dictionary, else default.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(dict.setdefault)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "update(...)\n",
      "    D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      "    If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      "    If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      "    In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(dict.update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list vs set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* méthodes communes à list et set:\n",
      "['clear', 'pop', 'remove', 'copy']\n",
      "\n",
      "* méthodes propres à list :\n",
      "['append', 'index', 'extend', 'sort', 'count', 'reverse', 'insert']\n",
      "\n",
      "* méthodes propres à set :\n",
      "['difference', 'add', 'union', 'symmetric_difference', 'isdisjoint', 'discard', 'intersection', 'intersection_update', 'issubset', 'issuperset', 'symmetric_difference_update', 'difference_update', 'update']\n"
     ]
    }
   ],
   "source": [
    "compare_methodes(list, set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "add(...)\n",
      "    Add an element to a set.\n",
      "    \n",
      "    This has no effect if the element is already present.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(set.add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dict vs set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* méthodes communes à dict et set:\n",
      "['pop', 'update', 'clear', 'copy']\n",
      "\n",
      "* méthodes propres à dict :\n",
      "['values', 'get', 'items', 'keys', 'fromkeys', 'setdefault', 'popitem']\n",
      "\n",
      "* méthodes propres à set :\n",
      "['difference', 'add', 'union', 'symmetric_difference', 'isdisjoint', 'discard', 'intersection', 'intersection_update', 'issubset', 'issuperset', 'remove', 'symmetric_difference_update', 'difference_update']\n"
     ]
    }
   ],
   "source": [
    "compare_methodes(dict, set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Compte occurences (étape 2)](../exercises/exercises.ipynb#Exercice-5-:-compte-occurences)"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}