codage.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b719be1f",
   "metadata": {},
   "source": [
    "# Codage - Cours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e390e046",
   "metadata": {},
   "source": [
    "## Ex 1 : documenter son code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "dc75c68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum_tableau(t):\n",
    "    \"\"\"cette fonction renvoie l'indice de la valeur maximale dans le tableau, le tableau état supposé non vide\"\"\"\n",
    "    m = 0                         # indice du max initialisé à 0\n",
    "    for i in range(len(t)):\n",
    "        if t[i] > t[m]:\n",
    "            m = i\n",
    "    return m                      # indice du max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "193626f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t[9] = 0.99445983\n",
      "t[10] = 0.99445983\n",
      "t[11] = 0.95013850\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0, 2, 20)\n",
    "t = -2*(x-1)**2+1\n",
    "\n",
    "indice_max = maximum_tableau(t)\n",
    "\n",
    "for i in range(indice_max - 1, indice_max + 2):\n",
    "    print(f\"t[{i}] = {t[i]:.8f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58459903",
   "metadata": {},
   "source": [
    "## Ex 2 : tester le code par petits bouts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4a34f455",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum_tableau(t):\n",
    "    \"\"\"cette fonction renvoie l'indice de la valeur maximale dans le tableau, le tableau état supposé non vide\"\"\"\n",
    "    if len(t) == 0:\n",
    "        return None\n",
    "    m = 0                         # indice du max initialisé à 0\n",
    "    for i in range(len(t)):\n",
    "        if t[i] > t[m]:\n",
    "            m = i\n",
    "    return m                      # indice du max\n",
    "\n",
    "def test_simple():\n",
    "    \"\"\"test de la fonction maximum_tableau\"\"\"\n",
    "    assert maximum_tableau([]) == None\n",
    "    assert maximum_tableau([2, 3, 1]) == 1\n",
    "    assert maximum_tableau([-3,-1,-2,-1]) == 1 or 3\n",
    "    \n",
    "test_simple()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c86ebc00",
   "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 [20]\u001b[0m, in \u001b[0;36m<cell line: 26>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     23\u001b[0m         \u001b[38;5;28;01massert\u001b[39;00m fonction_a_tester[i]([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m     24\u001b[0m         \u001b[38;5;28;01massert\u001b[39;00m fonction_a_tester[i]([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m3\u001b[39m\n\u001b[1;32m---> 26\u001b[0m \u001b[43mtest_multiple\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[1;32mIn [20]\u001b[0m, in \u001b[0;36mtest_multiple\u001b[1;34m()\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[38;5;124;03m\"\"\"test des 3 fonctions\"\"\"\u001b[39;00m\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(\u001b[38;5;241m3\u001b[39m):\n\u001b[1;32m---> 22\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m fonction_a_tester[i]([]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m     23\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m fonction_a_tester[i]([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m     24\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m fonction_a_tester[i]([\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m3\u001b[39m\n",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def maximum_tableau_0(t):\n",
    "    \"\"\"cette fonction renvoie l'indice de la valeur maximale dans le tableau, le tableau état supposé non vide\"\"\"\n",
    "    if len(t) == 0:\n",
    "        return None\n",
    "    m = 0                         # indice du max initialisé à 0\n",
    "    for i in range(len(t)):\n",
    "        if t[i] > t[m]:\n",
    "            m = i\n",
    "    return m                      # indice du max\n",
    "\n",
    "def maximum_tableau_1(t):\n",
    "    return 8\n",
    "\n",
    "def maximum_tableau_2(t):\n",
    "    if len(t) == 0:\n",
    "        return 8\n",
    "\n",
    "def test_multiple():\n",
    "    fonction_a_tester = [maximum_tableau_0, maximum_tableau_1, maximum_tableau_2]\n",
    "    \"\"\"test des 3 fonctions\"\"\"\n",
    "    for i in range(3):\n",
    "        assert fonction_a_tester[i]([]) == None\n",
    "        assert fonction_a_tester[i]([2, 3, 1]) == 1\n",
    "        assert fonction_a_tester[i]([-3,-1,-2,-1]) == 1 or 3\n",
    " \n",
    "test_multiple()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04179b8",
   "metadata": {},
   "source": [
    "## Ex 3 : notion d'invariant de boucle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "568ed9bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def division_euclidienne(a:int, b:int) -> int:\n",
    "    \"\"\"cette fonction fournie le quotient q et le reste r de la division euclidienne de a par b\"\"\"\n",
    "    q:int = 0\n",
    "    r:int = a\n",
    "    while r >= b:   # invariant : a = q*b + r\n",
    "        q += 1\n",
    "        r -= b\n",
    "    return q, r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1e41c4dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(division_euclidienne(17, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ea7fada2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1.4000000000000004)\n"
     ]
    }
   ],
   "source": [
    "print(division_euclidienne(17, 5.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fabfd8b3",
   "metadata": {},
   "source": [
    "<u> attention </u>: spécifier le type de données attendu ne bloque pas forcément le programe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25ac9572",
   "metadata": {},
   "source": [
    "## Ex 4 : test sophistiqué"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c88c8cd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tri(t):\n",
    "    # faire une fonction trier\n",
    "    return sorted(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a7c6f762",
   "metadata": {},
   "outputs": [],
   "source": [
    "def occurence(t):\n",
    "    \"\"\"renvoie le dictionnaire des occurences de t\"\"\"\n",
    "    d = {}\n",
    "    for x in t:\n",
    "        if x in d:\n",
    "            d[x] += 1\n",
    "        else:\n",
    "            d[x] = 1\n",
    "    return d\n",
    "\n",
    "def identique(d1, d2):\n",
    "    \"\"\"vérifie si d1 et d2 sont identiquent\"\"\"\n",
    "    for x in d1:\n",
    "        assert x in d2\n",
    "        assert d1[x] == d2[x]\n",
    "    \n",
    "    for x in d2:\n",
    "        assert x in d1\n",
    "        assert d2[x] == d1[x]   \n",
    "\n",
    "def test(t):\n",
    "    \"\"\"teste la fonction trisur le tableau t\"\"\"\n",
    "    occ = occurence(t)\n",
    "    t = tri(t)\n",
    "    for i in range(0, len(t) - 1):\n",
    "        assert t[i] <= t[i+1]\n",
    "    identique(occ, occurence(t))\n",
    "\n",
    "from random import randint\n",
    "\n",
    "def tableau_aleatoire(n, a, b):\n",
    "    return [a + randint(0, b-a) for _ in range(n)]\n",
    "\n",
    "for n in range(100):\n",
    "    test(tableau_aleatoire(n, 0, 0))\n",
    "    test(tableau_aleatoire(n, -n//4, n//4))\n",
    "    test(tableau_aleatoire(n, -10*n, 10*n))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "237ce764",
   "metadata": {},
   "source": [
    "## Ex 5 : Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5e426efe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2**0: 0.0000s\n",
      "2**4: 0.0000s\n",
      "2**8: 0.0000s\n",
      "2**12: 0.0010s\n",
      "2**16: 0.0060s\n",
      "2**20: 0.1011s\n",
      "2**24: 1.7649s\n",
      "2**28: 33.0647s\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "for k in range(0, 29, 4):\n",
    "    n = 2**k\n",
    "    tab = tableau_aleatoire(n, -100, 100)\n",
    "    temps_depart = time.time()\n",
    "    tri(tab)\n",
    "    print(f\"2**{k}: {time.time()-temps_depart:.4f}s\")   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1796796",
   "metadata": {},
   "source": [
    "# Codage - 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": 25,
   "id": "f8c5dd95",
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication classique\n",
    "def mult_1(x, y):\n",
    "    return x*y\n",
    "\n",
    "# multiplication russe\n",
    "def mult_2(x, y):\n",
    "    z = 0\n",
    "    # invariant = z + x * y\n",
    "    while y != 0:\n",
    "        if y % 2 == 1:\n",
    "            z = z + x\n",
    "        x = 2 * x\n",
    "        y = y // 2\n",
    "    return z\n",
    "\n",
    "from random import randint\n",
    "from time import time\n",
    "\n",
    "# technique d'encapsulation (voir chapitre suivant)\n",
    "def test(mult):\n",
    "    # test de valeur\n",
    "    for _ in range(100):\n",
    "        x = randint(-100, 100)\n",
    "        assert mult(0, x) == 0\n",
    "        assert mult(x, 0) == 0\n",
    "        assert mult(1, x) == x\n",
    "        y = randint(-100, 100)    \n",
    "        assert mult(x, y) == x*y\n",
    "        assert mult(y, x) == x*y\n",
    "    \n",
    "    #test de temps\n",
    "    for k in range(1, 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 = mult(x, y)\n",
    "        print(f\"{n} : {time() - t:.05f} s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fac0b96c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 : 0.00000 s\n",
      "4 : 0.00000 s\n",
      "8 : 0.00000 s\n",
      "16 : 0.00000 s\n",
      "32 : 0.00000 s\n",
      "64 : 0.00000 s\n",
      "128 : 0.00000 s\n",
      "256 : 0.00000 s\n",
      "512 : 0.00000 s\n",
      "1024 : 0.00000 s\n",
      "2048 : 0.00000 s\n",
      "4096 : 0.00000 s\n",
      "8192 : 0.00100 s\n",
      "16384 : 0.00100 s\n",
      "32768 : 0.00200 s\n",
      "65536 : 0.00900 s\n",
      "131072 : 0.02400 s\n",
      "262144 : 0.07502 s\n",
      "524288 : 0.21605 s\n"
     ]
    }
   ],
   "source": [
    "test(mult_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97d8ba5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "test(mult_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b85fd38",
   "metadata": {},
   "source": [
    "attention : ici python ne signale pas d'erreur mais le moteur ne n'arrête pas de calculer ; quel est le problème ? comment le détecter ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21cfd60c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication russe révisée ----> NE FONCTIONNE PAS !!!!!!!!!!!!!!!!!!!\n",
    "\n",
    "def mult_3(x, y):\n",
    "    i = 0                   # bloque une boucle infinie dans le while\n",
    "    z = 0\n",
    "    # invariant = z + x * y\n",
    "    while y != 0:\n",
    "        assert i != 1000    # bloque une boucle infinie dans le while\n",
    "        if y % 2 == 1:\n",
    "            z = z + x\n",
    "        x = 2 * x\n",
    "        y = y // 2\n",
    "        i += 1\n",
    "    return z\n",
    "\n",
    "from random import randint\n",
    "def test(mult):\n",
    "    # test de valeur\n",
    "    for _ in range(100):\n",
    "        x = randint(-100, 100)\n",
    "        assert mult(0, x) == 0\n",
    "        assert mult(x, 0) == 0\n",
    "        assert mult(1, x) == x\n",
    "        y = randint(-100, 100)    \n",
    "        assert mult(x, y) == x*y\n",
    "        assert mult(y, x) == x*y\n",
    "        \n",
    "test(mult_3)"
   ]
  },
  {
   "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": 22,
   "id": "7ec5b2db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mirroir_1(texte):\n",
    "    return \"bonjour\"[::-1]\n",
    "\n",
    "def mirroir_2(texte):\n",
    "    n = len(texte)\n",
    "    liste = [txt[-(i+1)] for i in range(n)]\n",
    "    reponse = ''.join(liste)\n",
    "    return reponse\n",
    "\n",
    "txt = \"bonjour\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9674c3f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ruojnob\n"
     ]
    }
   ],
   "source": [
    "print(mirroir_1(txt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d0e6f95f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ruojnob\n"
     ]
    }
   ],
   "source": [
    "print(mirroir_2(txt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "529994c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_1(text):\n",
    "    n = len(text)\n",
    "    reponse = mirroir_2(text)\n",
    "    assert len(reponse) == n\n",
    "    for i in range(n):\n",
    "        assert reponse[i] == text[n - (i+1)]\n",
    "    \n",
    "def test_2(text):\n",
    "    assert mirroir_2(text) == mirroir_1(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ac7145eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_1(\"bonjour\")\n",
    "test_2(\"bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0543412",
   "metadata": {},
   "source": [
    "## Ex 35 : retour sur la classe Chrono"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "019195a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Chrono:\n",
    "    \"\"\" classe pour représenter un temps mesuré en h, m, s \"\"\"\n",
    "    def __init__(self, h, m, s):    \n",
    "        self.h = h\n",
    "        self.m = m\n",
    "        self.s = s\n",
    "        self._temps = 3600*h + 60*m + s\n",
    "        \n",
    "    def avance(self, s):\n",
    "        self._temps += s\n",
    "        self.h = self._temps // 3600\n",
    "        self.m = (self._temps - 3600*self.h) // 60\n",
    "        self.s = self._temps - 3600*self.h - 60*self.m\n",
    "        \n",
    "    def recule(self, s):\n",
    "        self._temps -= s\n",
    "        self.h = self._temps // 3600\n",
    "        self.m = (self._temps - 3600*self.h) // 60\n",
    "        self.s = self._temps - 3600*self.h - 60*self.m       \n",
    "        \n",
    "    def texte(self):\n",
    "        return f\"{self.h} h {self.m} min {self.s} s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "08733594",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.2\n",
      "-25\n"
     ]
    }
   ],
   "source": [
    "temps = Chrono(12.2, -25, 12)\n",
    "print(temps.h)\n",
    "print(temps.m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14378e56",
   "metadata": {},
   "source": [
    "on modifie la classe pour aplier à ces problèmes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "08c7bc67",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Chrono:\n",
    "    \"\"\" classe pour représenter un temps mesuré en h, m, s \"\"\"\n",
    "    def __init__(self, h:int, m:int, s:int):\n",
    "        if h<0 or h>23 or m<0 or m>59 or s<0 or s>59:\n",
    "            raise ValueError(\"heure invalide\")     \n",
    "        self.h = h\n",
    "        self.m = m\n",
    "        self.s = s\n",
    "        self._temps = 3600*h + 60*m + s\n",
    "        \n",
    "    def avance(self, s):\n",
    "        self._temps += s\n",
    "        self.h = self._temps // 3600\n",
    "        self.m = (self._temps - 3600*self.h) // 60\n",
    "        self.s = self._temps - 3600*self.h - 60*self.m\n",
    "        \n",
    "    def recule(self, s):\n",
    "        self._temps -= s\n",
    "        self.h = self._temps // 3600\n",
    "        self.m = (self._temps - 3600*self.h) // 60\n",
    "        self.s = self._temps - 3600*self.h - 60*self.m       \n",
    "        \n",
    "    def texte(self):\n",
    "        return f\"{self.h} h {self.m} min {self.s} s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "9035bd14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.2\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "temps = Chrono(12.2, 25, 12)\n",
    "print(temps.h)\n",
    "print(temps.m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d1aeea1",
   "metadata": {},
   "source": [
    "<u>attention (rappel) </u> : le type attentu n'est pas bloquant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f52971d3",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "heure invalide",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [45]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m temps \u001b[38;5;241m=\u001b[39m \u001b[43mChrono\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m12.2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m25\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(temps\u001b[38;5;241m.\u001b[39mh)\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(temps\u001b[38;5;241m.\u001b[39mm)\n",
      "Input \u001b[1;32mIn [43]\u001b[0m, in \u001b[0;36mChrono.__init__\u001b[1;34m(self, h, m, s)\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, h:\u001b[38;5;28mint\u001b[39m, m:\u001b[38;5;28mint\u001b[39m, s:\u001b[38;5;28mint\u001b[39m):\n\u001b[0;32m      4\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m h\u001b[38;5;241m<\u001b[39m\u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m h\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m23\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m m\u001b[38;5;241m<\u001b[39m\u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m m\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m59\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m s\u001b[38;5;241m<\u001b[39m\u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m s\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m59\u001b[39m:\n\u001b[1;32m----> 5\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mheure invalide\u001b[39m\u001b[38;5;124m\"\u001b[39m)     \n\u001b[0;32m      6\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mh \u001b[38;5;241m=\u001b[39m h\n\u001b[0;32m      7\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mm \u001b[38;5;241m=\u001b[39m m\n",
      "\u001b[1;31mValueError\u001b[0m: heure invalide"
     ]
    }
   ],
   "source": [
    "temps = Chrono(12.2, -25, 12)\n",
    "print(temps.h)\n",
    "print(temps.m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c01090c",
   "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
}