module_erreur_exception.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b719be1f",
   "metadata": {},
   "source": [
    "# Module Erreur Exception - Cours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e390e046",
   "metadata": {},
   "source": [
    "## Ex 1 : gestion d'un exception complète"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dc75c68c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "entrer un numérateur : coucou\n",
      "erreur : la valeur n'est pas un entier\n",
      "nous sommes arrivé au bout du programme\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input(\"entrer un numérateur : \"))\n",
    "    y = int(input(\"entrer un dénominateur : \"))\n",
    "    z = x / y\n",
    "\n",
    "except ValueError:\n",
    "    print(\"erreur : la valeur n'est pas un entier\")\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"erreur : impossible de diviser par zéro\")\n",
    "          \n",
    "else:\n",
    "    print(f\"x / y = {int(z)}\")\n",
    "\n",
    "finally:\n",
    "    print(\"nous sommes arrivé au bout du programme\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a41d4cbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "entrer un numérateur : 6\n",
      "entrer un dénominateur : 2\n",
      "x / y = 3\n",
      "nous sommes arrivé au bout du programme\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input(\"entrer un numérateur : \"))\n",
    "    y = int(input(\"entrer un dénominateur : \"))\n",
    "    z = x / y\n",
    "\n",
    "except ValueError:\n",
    "    print(\"erreur : la valeur n'est pas un entier\")\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"erreur : impossible de diviser par zéro\")\n",
    "          \n",
    "else:\n",
    "    print(f\"x / y = {int(z)}\")\n",
    "\n",
    "finally:\n",
    "    print(\"nous sommes arrivé au bout du programme\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83337b1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "entrer un numérateur : 6\n",
      "entrer un dénominateur : 0\n",
      "erreur : impossible de diviser par zéro\n",
      "nous sommes arrivé au bout du programme\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input(\"entrer un numérateur : \"))\n",
    "    y = int(input(\"entrer un dénominateur : \"))\n",
    "    z = x / y\n",
    "\n",
    "except ValueError:\n",
    "    print(\"erreur : la valeur n'est pas un entier\")\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"erreur : impossible de diviser par zéro\")\n",
    "          \n",
    "else:\n",
    "    print(f\"x / y = {int(z)}\")\n",
    "\n",
    "finally:\n",
    "    print(\"nous sommes arrivé au bout du programme\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1796796",
   "metadata": {},
   "source": [
    "# Module Erreur Exception - Fiche d'ex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf84843a",
   "metadata": {},
   "source": [
    "## Ex 31 : test d'opération et de performance sur mult(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f8c5dd95",
   "metadata": {},
   "outputs": [],
   "source": [
    "def boite_noire_mult_1(x, y):\n",
    "    return x*y\n",
    "\n",
    "def boite_noire_mult_2(x, y):\n",
    "    return x*1\n",
    "\n",
    "from random import randint\n",
    "\n",
    "def test_operation_mult_1():\n",
    "    for _ in range(1000):\n",
    "        x = randint(-100, 100)\n",
    "        y = randint(-100, 100)\n",
    "        assert(boite_noire_mult_1(x, y) == x*y)\n",
    "        assert(boite_noire_mult_1(y, x) == x*y)\n",
    "    print(f\"le test s'est bien passé\")\n",
    "\n",
    "def test_operation_mult_2():\n",
    "    for _ in range(1000):\n",
    "        x = randint(-100, 100)\n",
    "        y = randint(-100, 100)\n",
    "        assert(boite_noire_mult_1(x, y) == x*y)\n",
    "        assert(boite_noire_mult_1(y, x) == x*y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2e39c559",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le test s'est bien passé\n"
     ]
    }
   ],
   "source": [
    "test_operation_mult_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fac0b96c",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_operation_mult_2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3377efed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1024 0.0\n",
      "2048 0.0\n",
      "4096 0.0\n",
      "8192 0.0009906291961669922\n",
      "16384 0.0010001659393310547\n",
      "32768 0.0030002593994140625\n",
      "65536 0.008001327514648438\n",
      "131072 0.023004770278930664\n",
      "262144 0.06914782524108887\n",
      "524288 0.21017122268676758\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "from time import time\n",
    "\n",
    "for k in range(10, 20):\n",
    "    n = 2**k\n",
    "    min, max = 10**(n-1), 10**n - 1\n",
    "    x = randint(min, max)\n",
    "    y = randint(min, max)\n",
    "    t = time()\n",
    "    z = boite_noire_mult_1(x, y)\n",
    "    print(n, time() - t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "580ea15a",
   "metadata": {},
   "source": [
    "lorsque n est multiplié par 2, le temps est approximativement multiplié par 4 ; il s'agit d'un algorithme à complexité quadratique ...\n",
    "voir cette page pour des précisions et exemples sur la [complexité algorithmique](https://info.blaisepascal.fr/nsi-complexite-dun-algorithme#:~:text=La%20complexit%C3%A9%20en%20temps%20d,nombre%20de%20donn%C3%A9es%20%C3%A0%20traiter.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d2001a8",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0a053bd",
   "metadata": {},
   "source": [
    "## Ex 32 : test sur la fonction mirroir(ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "442bcc6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mirroir_1(texte):\n",
    "    return \"\".join(reversed(texte))\n",
    "\n",
    "def mirroir_2(texte):\n",
    "    return texte[::-1]\n",
    "\n",
    "def mirroir_faux(texte):\n",
    "    return \"abc\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "348600a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cba  cba  abc\n"
     ]
    }
   ],
   "source": [
    "texte = \"abc\"\n",
    "\n",
    "a, b, c = mirroir_1(texte), mirroir_2(texte), mirroir_faux(texte)\n",
    "print(f\"{a}  {a}  {c}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c3bbbb42",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_mirroir_1(texte):\n",
    "    n = len(texte)\n",
    "    m = mirroir_1(texte)\n",
    "    assert len(m) == n\n",
    "    for i in range(n):\n",
    "        assert m[i] == texte[n - 1 - i]   \n",
    "    print(\"le test 1 s'est bien passé\")\n",
    "    \n",
    "def test_mirroir_2(texte):\n",
    "    n = len(texte)\n",
    "    m = mirroir_2(texte)\n",
    "    assert len(m) == n\n",
    "    for i in range(n):\n",
    "        assert m[i] == texte[n - 1 - i]   \n",
    "    print(\"le test 2 s'est bien passé\")  \n",
    "    \n",
    "def test_mirroir_faux(texte):\n",
    "    n = len(texte)\n",
    "    m = mirroir_faux(texte)\n",
    "    assert len(m) == n\n",
    "    for i in range(n):\n",
    "        assert m[i] == texte[n - 1 - i]\n",
    "    print(\"le test faux s'est bien passé\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6b1e2979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le test 1 s'est bien passé\n"
     ]
    }
   ],
   "source": [
    "test_mirroir_1(\"abcdef\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c558b07c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le test 2 s'est bien passé\n"
     ]
    }
   ],
   "source": [
    "test_mirroir_2(\"abcdef\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "17510762",
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[1;32mIn [29]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mtest_mirroir_faux\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mabcdef\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[1;32mIn [26]\u001b[0m, in \u001b[0;36mtest_mirroir_faux\u001b[1;34m(texte)\u001b[0m\n\u001b[0;32m     18\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(texte)\n\u001b[0;32m     19\u001b[0m m \u001b[38;5;241m=\u001b[39m mirroir_faux(texte)\n\u001b[1;32m---> 20\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(m) \u001b[38;5;241m==\u001b[39m n\n\u001b[0;32m     21\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n):\n\u001b[0;32m     22\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m m[i] \u001b[38;5;241m==\u001b[39m texte[n \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m i]\n",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test_mirroir_faux(\"abcdef\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c6a0b3b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# si l'on souhaite définir une chaine aléatoire\n",
    "\n",
    "from random import randint\n",
    "\n",
    "def chaine_aleatoire(n):\n",
    "    return \"\".join( [chr(randint(65, 90)) for _ in range(n)] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d4bf3127",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MELFKXKMZH'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chaine_aleatoire(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bbecb17",
   "metadata": {},
   "source": [
    "pour avoir l'ensemble des caractères UTF-8, le range doit être être 0 et 0x01FFFF "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ec5b2db",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}