amphi-7-old.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5745c18a",
   "metadata": {},
   "source": [
    "# Amphi du 22/11/2021\n",
    "\n",
    "- Questions diverses\n",
    "- Entraînement : dosctrings / doctests\n",
    "- Entraînement : listes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef84ee95",
   "metadata": {},
   "source": [
    "## Questions diverses"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47f83a9a",
   "metadata": {},
   "source": [
    "*À compléter.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5ab8e22",
   "metadata": {},
   "source": [
    "## Docstrings / doctests\n",
    "\n",
    "**Objectifs :** \n",
    "\n",
    "- Pour soi-même :\n",
    "    - Réfléchir à la *spécification* (ce que *devrait* faire) un programme, et à la *correction* du code.\n",
    "    - Se convaincre, à l'aide d'exemples (tests), que la fonction qu'on vient d'écrire est correcte\n",
    "- Pour quelqu'un d'autre :\n",
    "    - Expliquer et montrer à quelqu'un à quoi sert une fonction et comment on l'utilise.\n",
    "    - Convaincre quelqu'un, à l'aide d'exemples (tests), qu'une fonction fait bien ce qu'elle prétend faire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "90c0e82f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from doctest import testmod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d783fb7",
   "metadata": {},
   "source": [
    "### Exercice 1 : nombres premiers\n",
    "\n",
    "On considère le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d6fb214",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def est_premier(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return False\n",
    "    for i in range(2, int(sqrt(n)) + 1):\n",
    "        if n % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def compte(donnees):\n",
    "    p = 0\n",
    "    c = 0\n",
    "    for i in range(len(donnees)):\n",
    "        if est_premier(donnees[i]):\n",
    "            p += 1\n",
    "        else:\n",
    "            c += 1\n",
    "    return p, c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e644b02a",
   "metadata": {},
   "source": [
    "Écrire pour chacune de ces fonctions une *docstring* et des *doctests* pertinents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8260dbf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(est_premier)\n",
    "help(compte)\n",
    "testmod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e6793f0",
   "metadata": {},
   "source": [
    "### Exercice 2 : tirage de dés\n",
    "\n",
    "On considère le code suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "54173fd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint, seed\n",
    "\n",
    "def lance(f):\n",
    "    \"\"\" Simule le lancer d'un dé à f faces\n",
    "\n",
    "    :param f: int\n",
    "    :return value: int, compris entre 1 et f\n",
    "\n",
    "    >>> from random import seed\n",
    "    >>> seed(42)\n",
    "    >>> lance(0) is None\n",
    "    True\n",
    "    >>> lance(6)\n",
    "    6\n",
    "    \"\"\"\n",
    "    if f >= 1:\n",
    "        return randint(1, f)\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c0273d13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method randint in module random:\n",
      "\n",
      "randint(a, b) method of random.Random instance\n",
      "    Return random integer in range [a, b], including both end points.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(randint)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea87b3ae",
   "metadata": {},
   "source": [
    "Pour comprendre le *doctest* dans la fonction `lance` ci-dessus, on fait les observations suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1b3f05b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a3faac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(42)\n",
    "[random.randint(1, 2) for _ in range(20)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4ec9402f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 1, 1, 6, 3, 2, 2, 2, 6, 1, 6, 6, 5, 1, 5, 4, 1, 1, 1, 2]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(42)\n",
    "[random.randint(1, 6) for _ in range(20)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f45b5140",
   "metadata": {},
   "source": [
    "Soient les fonctions `foo` et `bar` ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fa3f55af",
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(n, f, x):\n",
    "    \"\"\"\n",
    "    Renvoie True si le résultat x apparaît au moins une fois\n",
    "    au cours de n lancers de dé à f faces simulés avec la fonction\n",
    "    lance(f), et False sinon.\n",
    "    \n",
    "    :param int n: nombre de lancers\n",
    "    :param inf f: nombre de faces du dé\n",
    "    :param int x: résultat recherché\n",
    "    :return bool: True si x apparaît, False sinon\n",
    "    \n",
    "    >>> seed(42)\n",
    "    >>> foo(5, 6, 3)\n",
    "    True\n",
    "    >>> foo(8, 6, 4)\n",
    "    False\n",
    "    >>> foo(1, 0, 1)\n",
    "    False\n",
    "    >>> foo(0, 1, 1)\n",
    "    False\n",
    "    \"\"\"\n",
    "    o = False\n",
    "    for p in range(n):\n",
    "        if x == lance(f):\n",
    "            o = True\n",
    "    return o\n",
    "   \n",
    "def bar(n, f, x):\n",
    "    if not(n <= 0 or f <= 0):\n",
    "        cmpt = 1\n",
    "        while not foo(n, f, x):\n",
    "            cmpt += 1\n",
    "        return cmpt\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6d3a666",
   "metadata": {},
   "source": [
    "Proposer des *docstring* et *doctests* pertinents pour ces deux fonctions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4714cf05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function foo in module __main__:\n",
      "\n",
      "foo(n, f, x)\n",
      "    Renvoie True si le résultat x apparaît au moins une fois\n",
      "    au cours de n lancers de dé à f faces simulés avec la fonction\n",
      "    lance(f), et False sinon.\n",
      "    \n",
      "    :param int n: nombre de lancers\n",
      "    :param inf f: nombre de faces du dé\n",
      "    :param int x: résultat recherché\n",
      "    :return bool: True si x apparaît, False sinon\n",
      "    \n",
      "    >>> seed(42)\n",
      "    >>> foo(5, 6, 3)\n",
      "    True\n",
      "    >>> foo(8, 6, 4)\n",
      "    False\n",
      "    >>> foo(1, 0, 1)\n",
      "    False\n",
      "    >>> foo(0, 1, 1)\n",
      "    False\n",
      "\n",
      "Help on function bar in module __main__:\n",
      "\n",
      "bar(n, f, x)\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "TestResults(failed=0, attempted=9)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "help(foo)\n",
    "help(bar)\n",
    "testmod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d42beb",
   "metadata": {},
   "source": [
    "### Exercice 3 : mystère... (?)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "888d66ec",
   "metadata": {},
   "source": [
    "Proposer des docstring et doctests pertinents pour les deux fonctions suivantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bedfe696",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mystere_1(datas):\n",
    "    \"\"\"\n",
    "    >>> mystere_1([1, 2, 3, 2])\n",
    "    [1, 2, 3]\n",
    "    \n",
    "    >>> mystere_1([9, 9, 9, 9, 9])\n",
    "    [9]\n",
    "    \n",
    "    >>> mystere_1([\"bonjour\", 0, \"mardi\", \"mardi\", \"rouge\", 0])\n",
    "    ['bonjour', 0, 'mardi', 'rouge']\n",
    "    \n",
    "    >>> mystere_1([])\n",
    "    []\n",
    "    \n",
    "    >>> mystere_1(\"abbatiale\")\n",
    "    ['a', 'b', 't', 'i', 'l', 'e']\n",
    "    \n",
    "    \"\"\"\n",
    "    lst = []\n",
    "    for i in range(len(datas)):\n",
    "        est_present = False\n",
    "        for j in range(len(lst)):\n",
    "            if datas[i] == lst[j]:\n",
    "                est_present = True\n",
    "        if not est_present:\n",
    "            lst.append(datas[i])\n",
    "    return lst\n",
    "\n",
    "def mystere_2(datas):\n",
    "    \"\"\"\n",
    "    >>> lst = [\"bonjour\", 0, \"mardi\", \"mardi\", \"rouge\", 0]\n",
    "    >>> mystere_2(lst)\n",
    "    >>> lst\n",
    "    ['bonjour', 0, 'mardi', 'rouge']\n",
    "    \n",
    "    \"\"\"\n",
    "    pos = 0\n",
    "    while pos < len(datas):\n",
    "        est_present = False\n",
    "        for i in range(pos):\n",
    "            if pos < len(datas) and datas[pos] == datas[i]:\n",
    "                datas.pop(pos)\n",
    "                est_present = True\n",
    "        if not est_present:\n",
    "            pos += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "05c19dcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function mystere_1 in module __main__:\n",
      "\n",
      "mystere_1(datas)\n",
      "    >>> mystere_1([1, 2, 3, 2])\n",
      "    [1, 2, 3]\n",
      "    \n",
      "    >>> mystere_1([9, 9, 9, 9, 9])\n",
      "    [9]\n",
      "    \n",
      "    >>> mystere_1([\"bonjour\", 0, \"mardi\", \"mardi\", \"rouge\", 0])\n",
      "    ['bonjour', 0, 'mardi', 'rouge']\n",
      "    \n",
      "    >>> mystere_1([])\n",
      "    []\n",
      "    \n",
      "    >>> mystere_1(\"abbatiale\")\n",
      "    ['a', 'b', 't', 'i', 'l', 'e']\n",
      "\n",
      "Help on function mystere_2 in module __main__:\n",
      "\n",
      "mystere_2(datas)\n",
      "    >>> lst = [\"bonjour\", 0, \"mardi\", \"mardi\", \"rouge\", 0]\n",
      "    >>> mystere_2(lst)\n",
      "    >>> lst\n",
      "    ['bonjour', 0, 'mardi', 'rouge']\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "TestResults(failed=0, attempted=17)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "help(mystere_1)\n",
    "help(mystere_2)\n",
    "testmod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12e35ded",
   "metadata": {},
   "source": [
    "## Listes\n",
    "\n",
    "### Exercice 4 : ensembles finis\n",
    "\n",
    "Dans cet exercice on considère uniquement des listes sans doublon et dont les éléments sont\n",
    "triés par ordre croissant. Ce genre de listes peut être utilisé pour représenter des ensembles. Par exemple l'ensemble $\\{1, 3, 2, 1, 1, -4\\}$ peut être représenté par la liste `[-4, 1, 2, 3]`.\n",
    "\n",
    "**Remarques :**\n",
    "\n",
    "- Dans chacune des fonctions suivantes, les paramètres `un` et `deux` sont des listes de ce type. \n",
    "- On veillera à ne parcourir chacune des listes fournies en argument qu’*une seule fois* (pas de boucles imbriquées).\n",
    "- Il existe des techniques plus efficaces pour représenter des ensembles.\n",
    "\n",
    "**Questions.**\n",
    "\n",
    "1. Écrire une fonction `inclus_dans(un, deux)` qui renvoie `True` si tous les éléments de `un` appartiennent à `deux`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "710269c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TestResults(failed=0, attempted=21)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def inclus_dans(un, deux):\n",
    "    \"\"\"\n",
    "    Renvoie True ssi l'ensemble un est inclus dans l'ensemble deux.\n",
    "    \n",
    "    >>> inclus_dans([2, 4], [1, 2, 3, 4])\n",
    "    True\n",
    "    \n",
    "    >>> inclus_dans([2, 5], [1, 2, 3, 4])\n",
    "    False\n",
    "\n",
    "    >>> inclus_dans([2, 5], [2])\n",
    "    False\n",
    "\n",
    "    >>> inclus_dans([2, 5], [2, 5])\n",
    "    True\n",
    "    \"\"\"\n",
    "    c1, c2 = 0, 0\n",
    "    \n",
    "    while c1 < len(un) and c2 < len(deux):\n",
    "        if un[c1] == deux[c2]:\n",
    "            c1 += 1\n",
    "            c2 += 1\n",
    "        elif un[c1] > deux[c2]:\n",
    "            c2 += 1\n",
    "        else:  # un[c1] < deux[c2]\n",
    "            return False\n",
    "    return c1 == len(un)\n",
    "\n",
    "testmod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98bc5d91",
   "metadata": {},
   "source": [
    "2. Écrire une fonction disjoint(un, deux) qui renvoie True si un et deux représentent des ensembles disjoints, et False sinon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51c066d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ea04c4e3",
   "metadata": {},
   "source": [
    "3. Écrire une fonction intersection(un, deux) qui renvoie la liste triée sans doublon con- tenant uniquement les éléments communs aux deux listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f9bd50b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "031f5406",
   "metadata": {},
   "source": [
    "4. Écrire une fonction difference(un, deux) qui renvoie la liste triée sans doublon contenant tous les éléments appartenant à un mais pas à deux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c1d283b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f58490e1",
   "metadata": {},
   "source": [
    "5. Écrire une fonction union(un, deux) qui renvoie la liste triée sans doublon contenant tous les éléments appartenant à un ou deux (ou au deux)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2420883f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "be027191",
   "metadata": {},
   "source": [
    "6. Écrire une fonction difference_symetrique(un, deux) qui renvoie la liste triée sans doublon contenant tous les éléments appartenant soit à un, soit à deux (mais pas aux deux)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "756df983",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}