{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f9d834a9",
   "metadata": {},
   "source": [
    "# Programmation orientée objet\n",
    "\n",
    "Comment créer se propres objets en Python. \n",
    "\n",
    "## Vocabulaire\n",
    "\n",
    "En python tout ce que l'on manipule est un objet : \n",
    "* Nombre, liste, dictionnaire, ...\n",
    "* Tableau numpy\n",
    "* Fonction, module, ....\n",
    "\n",
    "Un objet possède des **attributs**. Exemple : \n",
    "\n",
    "    z = 1.1J\n",
    "    z.real\n",
    "    a = np.array([1, 2, 4])\n",
    "    a.shape\n",
    "    \n",
    "Un objet possède des **méthodes**. Exemple :\n",
    "\n",
    "    a.mean()\n",
    "    a.conjugate()\n",
    "    z.conjugate()\n",
    "    \n",
    "Les méthodes sont des fonctions attachées à l'objet. La méthode conjugate d'un tableau n'est pas la même fonction que la méthode conjugate d'un complexe. \n",
    "\n",
    "## Comment créer un objet\n",
    "\n",
    "### Créer un object vecteur\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3a36865e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vecteur(4, 7, 4)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Vecteur():\n",
    "    def __init__(self, x, y, z):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.z = z\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'Vecteur({self.x}, {self.y}, {self.z})'\n",
    "    \n",
    "    def norme(self):\n",
    "        return sqrt(self.x**2 + self.y**2 + self.z**2)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Vecteur):\n",
    "            return Vecteur(self.x + other.x, self.y+other.y, self.z+other.z)\n",
    "        return NotImplemented\n",
    "    \n",
    "    \n",
    "v1 = Vecteur(1, 2, 3)\n",
    "v2 = Vecteur(3, 5, 1)\n",
    "v1 + v2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836e3bac",
   "metadata": {},
   "source": [
    "### Attributs d'objet et de class\n",
    "\n",
    "Les classes sont des objets comme les autres. Elles ont des attributs. Ce sont tous les objets définis dans la classe. Si un objet ne possède pas l'attribut auquel ou souhaite accéder, c'est l'attribut de la classe qui est renvoyée si celui ci existe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b5b60753",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class Test():\n",
    "    a = 1\n",
    "    \n",
    "t = Test()\n",
    "print(t.a) # Ici on va chercher l'attribut de Test\n",
    "t.a = 2 # A est maintenant un attribut de l'objet\n",
    "print(Test.a) # Test possède toujours sont attribut a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03b563b9",
   "metadata": {},
   "source": [
    "Les méthodes sont des fonctions qui sont des attributs de la classe. C'est lorsque l'on accède à cette attribut par l'objet, une transformation se passe et Python rajoute automatiquement l'objet comme premier argument. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a55d119",
   "metadata": {},
   "source": [
    "### Instance et héritage\n",
    "\n",
    "L’héritage est un mécanisme qui permet, lors de la déclaration d’une nouvelle classe, d'y inclure les caractéristiques d’une autre classe. \n",
    "\n",
    "Un objet est une instance de sa classe. On peut le tester avec la méthode ``isinstance``. Il est aussi une instance de toutes les classes dont hérite sa classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c9e5d9b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class FormeGeometrique:\n",
    "    pass\n",
    "\n",
    "class Polygone(FormeGeometrique):\n",
    "    pass\n",
    "\n",
    "class Cercle(FormeGeometrique):\n",
    "    def __init__(self, r):\n",
    "        self.r = r\n",
    "        \n",
    "    def surface(self):\n",
    "        return math.pi*r**2\n",
    "\n",
    "class Rectangle(Polygone):\n",
    "    def __init__(self, largeur, longueur):\n",
    "        self.largeur = largeur\n",
    "        self.longueur = longueur\n",
    "        \n",
    "    def surface(self):\n",
    "        return self.largeur * self.longueur\n",
    "    \n",
    "objet = Rectangle(2, 3)\n",
    "print(objet.surface())\n",
    "\n",
    "isinstance(rect, Polygone)\n",
    "\n",
    "def volume_prisme(base, hauteur):\n",
    "    return base.surface()*hauteur\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88ee69ba",
   "metadata": {},
   "source": [
    "L'utilsation de classes permet d'écrire des méthodes ayant le même nom, mais différentes pour chaque objet. La fonction volume_prisme fonctionne pour tout type de FormeGeometrique possédant une méthode surface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf724c6b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8a415faa",
   "metadata": {},
   "source": [
    "\n",
    "### Méthodes spéciales\n",
    "\n",
    "- `__init__`\n",
    "- `__repr__`, `__str__`\n",
    "\n",
    "Lorsque c'est possible, `__repr__` doit représenter au mieux l'objet. Souvent il s'agit d'une chaine de caractère qui en étant évaluée renvoie un objet similaire. La méthode `__str__` renvoie `__repr__` par défaut. Sinon, elle doit être plus simple.\n",
    "\n",
    "Opérateur unaire et binaire\n",
    "\n",
    "- `__neg__`\n",
    "- `__add__`, `__sub__`, `__mul__`, `__truediv__`, `__mod__`, `__pow__`\n",
    "- `__radd__`, ...\n",
    "- `__eq__` (==), `__ne__` (!=), `__lt__` (<), `__le__` (<=), `__gt__`, `__ge__`\n",
    "- `__or__` (|), `__and__` (&), `__xor__`(^)\n",
    "\n",
    "\n",
    "Emulateur de contenu\n",
    "\n",
    "- a[key] => `a.__getitem__(key)`\n",
    "- a[key] = val => `a.__setitem__(key, val)`\n",
    "- del a[key] => `a.__delitem__(key)`\n",
    "- len(a) => `a.__len__()`\n",
    "- for elm in a => `for elm in a.__iter__()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "181eb08f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}