programmation_objet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "63006dec",
   "metadata": {},
   "source": [
    "# Programmation Objet - ex du cours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ee144e4",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad71937d",
   "metadata": {},
   "source": [
    "## Ex 1 : créer une classe Chrono comportant 3 attributs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f8c5dd95",
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2e39c559",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Chrono(21, 34, 55)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ffd134a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Chrono'> <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(t), type(t.h))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fac0b96c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l'heure actuelle est 55 h 34 m 55 s\n"
     ]
    }
   ],
   "source": [
    "print(\"l'heure actuelle est\", t.s, \"h\", t.m, \"m\", t.s, \"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aacebb7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'heure actuelle est 21 h 34 m 55 s\n"
     ]
    }
   ],
   "source": [
    "print (f\"L'heure actuelle est {t.h} h {t.m} m {t.s} s\")      # utilisation des f-strings (extrêment pratique)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d2001a8",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8aed1fa",
   "metadata": {},
   "source": [
    "## Ex 2 : ajouter une méthode qui donne l'heure à la classe Chrono"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "442bcc6c",
   "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",
    "        \n",
    "    def texte(self):\n",
    "        return str(self.h) + \" h \" + str(self.m) + \" m \" + str(self.s) + \" s \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bceb8b05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 h 34 m 55 s  <class 'method'> <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "t = Chrono(21, 34, 55)\n",
    "print(t.texte(), type(t.texte), type(t.texte()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b00119",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fae3e37",
   "metadata": {},
   "source": [
    "## Ex 3 : enrichissement de la classe Chrono pour un affichage rapide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "749230b2",
   "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": 21,
   "id": "78b001ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'il était au départ 21 h 15 min 34 s ; en ajoutant 1700s, il est 21 h 43 min 54 s ; en enlevant 450s, il est 21 h 36 min 24 s'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = Chrono(21,15,34)\n",
    "a = t.texte()\n",
    "\n",
    "t_1 = t.avance(1700)\n",
    "b = t.texte()\n",
    "\n",
    "t_2 = t.recule(450)\n",
    "c = t.texte()\n",
    "\n",
    "f\"il était au départ {a} ; en ajoutant 1700s, il est {b} ; en enlevant 450s, il est {c}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "31417d2e",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid character '—' (U+2014) (3098221836.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Input \u001b[1;32mIn [1]\u001b[1;36m\u001b[0m\n\u001b[1;33m    — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid character '—' (U+2014)\n"
     ]
    }
   ],
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "276c815c",
   "metadata": {},
   "source": [
    "# Programmation Objet - fiche d'ex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70229f2f",
   "metadata": {},
   "source": [
    "## Ex 21 : classe Fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "44f7144c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# précision sur les __\n",
    "# https://www.pythoniste.fr/python/la-signification-des-traits-de-soulignement-_-en-python/#:~:text=Un%20double%20pr%C3%A9fixe%20de%20soulignement,mutileur%20de%20noms%20name%20mangling).\n",
    "\n",
    "\n",
    "class Fraction:\n",
    "    def __init__(self, n, d):\n",
    "        if d <=0:\n",
    "            raise ValueError(f\"{d} n'est pas strictement positif\")\n",
    "        self.num = n\n",
    "        self.denom = d\n",
    "        \n",
    "    def __str__(self):\n",
    "        if self.denom == 1:\n",
    "            return str(self.num)\n",
    "        return f\"{str(self.num)} / {str(self.denom)}\"\n",
    "        \n",
    "    def __eq__(self, f):\n",
    "        return self.num*f.denom == self.denom*f.num\n",
    "    \n",
    "    def __lt__(self,f):\n",
    "        return self.num*f.denom < self.denom*f.num    \n",
    "    \n",
    "    def __add__(self, f):\n",
    "        return Fraction(self.num*f.denom + f.denom*self.denom, self.denom*f.denom)\n",
    "         \n",
    "    def __mult__(self, f):\n",
    "        return Fraction(self.num*f.num, self.denom*f.denom)\n",
    "    \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3e47d889",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = Fraction(2,3), Fraction(3,1), Fraction(4,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ecd79187",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 2 / 3 , b = 3 , c = 4 / 6\n"
     ]
    }
   ],
   "source": [
    "print(f\"a = {a} , b = {b} , c = {c}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "088d3ce0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(a == b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ec8075a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(a.__eq__(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b9139c82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print( a == c )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0b9a127",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceb9df99",
   "metadata": {},
   "source": [
    "## Ex 22 : classe Intervalle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b1a562b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Intervalle:\n",
    "    \"\"\"classe pour représenter un intervalle fermé d'extrémités a et b, considéré vide si b < a\"\"\"\n",
    "    \n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        \n",
    "    def est_vide(self):\n",
    "        return self.b < self.a\n",
    "    \n",
    "    def __len__(self):\n",
    "        return max(0, self.b - self.a)\n",
    "    \n",
    "    def contains(self, x):\n",
    "        return self.a <= x <= self.b\n",
    "\n",
    "    def __eq__(self, i):\n",
    "        return ( self.est_vide() and i.est_vide() ) or ( self.a == i.a and self.b == i.b )\n",
    "    \n",
    "    def intersection(self, i):\n",
    "        return Intervalle( max(self.a ,i.a ), min(self.b ,i.b ) )\n",
    "    \n",
    "    def reunion(self, i):\n",
    "        return Intervalle( min(self.a ,i.a ), max(self.b ,i.b ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "71aa3fc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "A, B, x, D, E = Intervalle(1, 4), Intervalle(1, 1), 3, Intervalle(2, 5),  Intervalle(5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "444722ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.est_vide()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c3dc7dfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.est_vide()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a76114ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E.est_vide()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0b4c7383",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.__len__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "22e5ad81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.contains(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d82eafeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(min(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5ca95d78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INTERSECTION = [  1  ;  5  ]\n",
      "REUNION = [  2  ;  4  ]\n"
     ]
    }
   ],
   "source": [
    "min_intersection = A.intersection(D).a\n",
    "max_intersection = A.intersection(D).b\n",
    "\n",
    "min_reunion = A.reunion(D).a\n",
    "max_reunion = A.reunion(D).b\n",
    "\n",
    "print(\"INTERSECTION = [ \", min_reunion, \" ; \" , max_reunion , \" ]\")\n",
    "print(\"REUNION = [ \", min_intersection, \" ; \" , max_intersection , \" ]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb8e58a",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b84ee17d",
   "metadata": {},
   "source": [
    "## Ex 22 : classe Angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "07c95859",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos, sin, pi\n",
    "\n",
    "class Angle:\n",
    "    \"\"\"classe pour représenter un angle compris entre 0 et 360°\"\"\"\n",
    "    \n",
    "    def __init__(self, a):\n",
    "        self.angle = a % 360\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.angle + \" degrés\"\n",
    "    \n",
    "    def ajoute(self, a):\n",
    "        self.angle = ( self.angle + a.angle ) % 360\n",
    "        \n",
    "    def radians(self):\n",
    "        return self.angle * math.pi / 180\n",
    "    \n",
    "    def cos(self):\n",
    "        return cos(self.radians())\n",
    "    \n",
    "    def sin(self):\n",
    "        return sin(self.radians())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8d0fc63c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = Angle(360 + 45), Angle(-180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4709d2cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9008b19c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "180"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2126cee0",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.ajoute(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2c1ea6c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "225"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b0a31b98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.cos()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "995550e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sin()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03bd3481",
   "metadata": {},
   "source": [
    "— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a69917e",
   "metadata": {},
   "source": [
    "## Ex 24 : classe Date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7c029787",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Date:\n",
    "    \"\"\"classe pour représenter une date\"\"\"\n",
    "    \n",
    "    def __init__(self, a, b, c):\n",
    "        self.jour = a\n",
    "        self.mois = b\n",
    "        self.annee = c\n",
    "        \n",
    "    nom_mois = [\"janvier\", \"février\", \"mars\", \"avril\", \"mai\", \"juin\", \"juillet\", \"août\", \"septembre\", \"octobre\", \"novembre\", \"décembre\"]\n",
    "        \n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{self.jour} {self.nom_mois[self.mois - 1]} {self.annee}\"\n",
    "    \n",
    "    # def __repr__(self):\n",
    "    #    return f\"{self.jour} {self.nom_mois[self.mois - 1]} {self.annee}\"\n",
    "    \n",
    "    \n",
    "    def plus_petit_que(self, d):\n",
    "        if self.annee < d.annee:\n",
    "            return True\n",
    "        elif (self.annee == d.annee) and (self.mois < d.mois):\n",
    "            return True\n",
    "        elif (self.annee == d.annee) and (self.mois == d.mois) and (self.jour < d.jour):\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f15e5350",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c, d = Date(20, 6, 2001), Date(22, 6, 2002), Date(20, 8, 2001), Date(22, 6, 2001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "19ed6f5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Date at 0x1ca6a443460>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac530a6f",
   "metadata": {},
   "source": [
    "remarque 1 : c'est l'affichage de la représentation de l'objet (son adresse) ; elle peut être changé en reprogrammant __repr__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3425ca3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 juin 2001\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "247633fd",
   "metadata": {},
   "source": [
    "remarque 2 : c'est le print de l'objet (son adresse) ; il peut être changé en reprogrammant le __str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5f721607",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.plus_petit_que(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40abdc97",
   "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
}