01_06_Programmation_orientee_object_avec_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce notebook, nous verrons les bases de la Programmation orientée Objet ou POO. Nous apprendrons ici le strict nécéssaire  de façon pratique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supposon que nous souhaitons créer un jeu avec des personnages de type différent (voleur, police) qui pourront interagir entre elles, avoir et conduire des voitures, mourir et plein d'autres choses. Voleur et police ont probablement des attributs en commun, ils sont tous humains. Toutes les voitures one également des attributs en commun (4 roues par exemple) et des fonctions en commun (rouler par exemple). Avec la POO, nous souhaitons rendre notre code beaucoup plus simple en créant des objets qui ont des attributs et fonctions afin de pouvoir les réutiliser et adapter facilement quand le besoin se présente.\n",
    "\n",
    "Prenons un exemple plus simple:\n",
    "Créer 2 points A et B et calcule la distance entre ces 2 points.\n",
    "\n",
    "Chaque point a 2 coordonées, une x et une y. Tu feras donc ceci : \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_A = 2\n",
    "y_A = 5\n",
    "x_B = 2\n",
    "y_B = 1\n",
    "d = distance(x_A, y_A, x_B, y_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta solution est pas mal, mais il t'a fallu créer 4 variables pour représenter 2 points. Et si chacun des points avait 15 attributs, il te faudra 30 variables et ta fonction distance risque de se compliquer. De plus quelqu'un qui lit ton code peut ne pas comprendre que ce sont des points que tu es entrain de representer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pensons plutôt à un point comme un objet qui a 2 attributs x et y. Le code en haut deviendrait:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Point(2, 5)\n",
    "B = Point(2, 1)\n",
    "d = distance (A, B) # ou d = A.distance(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant qu'on a compris un peu de quoi il s'agit, parlons du concept de classe. Une classe en POO represente la moule qui permet de créer des objets. Dans le code ci-dessus, `Point` est une classe qu'on a utilisé pour créer les points A et B. Créons le code pour la classe Point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, abscisse, ordonne):\n",
    "        self.x = abscisse\n",
    "        self.y = ordonne\n",
    "    \n",
    "    def distance(self, autre_point):\n",
    "        squarred_d = (autre_point.x - self.x)**2 + (autre_point.y - self.y)**2\n",
    "        d = math.sqrt(squarred_d)\n",
    "        return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Point(2, 3)\n",
    "b = Point(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.23606797749979"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.distance(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `__init__` est appélé constructeur. C'est dans cette fonction que nous définissons les atributs de notre classe. Le mot clé `self` représente un objet ou une instance de notre classe. La fonction **__init__** attribue donc à x et y respectivement l'abcisse et l'ordonné reçue."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction distance prend en entrée le point actuel et un autre point et calcule leur distance. On peut déjà remarquer que pour avoir accès aux attributs d'un objet, on utilise le format `objet.attribut`. Exemple : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons afficher un objet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Point object at 0x7fa1c42a0090>\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce n'est pas ce à quoi on s'attendait. On aimerait qu'en faisant print(objet), on obtienne des informations sur ses attributs. C'est possible avec la fonction spéciale **__repr__** comme ceci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, abscisse, ordonne):\n",
    "        self.x = abscisse\n",
    "        self.y = ordonne\n",
    "    \n",
    "    def distance(self, autre_point):\n",
    "        squarred_d = (autre_point.x - self.x)**2 + (autre_point.y - self.y)**2\n",
    "        d = math.sqrt(squarred_d)\n",
    "        return d\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Ce point a pour abcisse {self.x} et ordonné {self.y}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_point = Point(5, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 5 et ordonné 8\n"
     ]
    }
   ],
   "source": [
    "print(un_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "autre_point = Point(-1, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse -1 et ordonné 6\n"
     ]
    }
   ],
   "source": [
    "print(autre_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.324555320336759"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "un_point.distance(autre_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.324555320336759"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "autre_point.distance(un_point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons ajouter quelques autres fonctions à notre classe Point. Nous pouvons par exemple définir une fonction qui ramène le point à l'origine, donc à x=0 et y=0, une fonction qui la projecte sur l'axe des abcisses donc y=0 et une autre qui la projecte sur l'axe des ordonnées donc x=0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, abscisse, ordonne):\n",
    "        self.x = abscisse\n",
    "        self.y = ordonne\n",
    "    \n",
    "    def distance(self, autre_point):\n",
    "        squarred_d = (autre_point.x - self.x)**2 + (autre_point.y - self.y)**2\n",
    "        d = math.sqrt(squarred_d)\n",
    "        return d\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Ce point a pour abcisse {self.x} et ordonné {self.y}\"\n",
    "    \n",
    "    def origine(self):\n",
    "        self.x = 0\n",
    "        self.y = 0\n",
    "    \n",
    "    def projection_x(self):\n",
    "        self.y = 0\n",
    "        \n",
    "    def projection_y(self):\n",
    "        self.x = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Point(5, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 5 et ordonné 8\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.origine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 0 et ordonné 0\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = Point(9, -4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 9 et ordonné -4\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.projection_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 9 et ordonné 0\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 6 et ordonné 7\n"
     ]
    }
   ],
   "source": [
    "c = Point(6, 7)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.projection_y()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ce point a pour abcisse 0 et ordonné 7\n"
     ]
    }
   ],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà les bases à connaitre sur la programmation Orientée Objet.\n",
    "\n",
    "Quelques concepts et mots dont vous entendrez parler si vous faites un peu plus de recherches sur l'Orienté objet!\n",
    "\n",
    "> Encapsulation : On dit qu'on a encapsulé les variables dans un objet avec des fonctions qui peuvent modifier ces variables. Ces variables ne sont pas accessibles en dehors de l'objet et sont modifiables uniquement par les fonctions définies dans la classe\n",
    "\n",
    "> Polymorphisme: Avec l'orientée objet, on peut définir une fonction qui a la possibilité de fonctionner avec différents types de données. C'est l'exemple de la fonction len qui peut être utilisé avec une chaine de caractère, une liste ou un dictionnaire pour calculer sa taille. Un exemple réel serait une classe Personne avec une fonction salutation qui laissera chaque personne saluer de la façon dont c'est fait dans sa culture.\n",
    "\n",
    "> Heritage : C'est la possibilité de créer une classe en se basant sur une autre. La nouvelle classe hérite des attributs et fonctions de la précédente mais aussi avoir ses propres fonctionnalités et attributs. Un exemple réel serait une classe Adulte qui hérite de la classe humain mais qui a ses propres attributs comme statut_matrimonial et des fonctions comme acheter_une_maison."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est la fin de ce notebook et des bases de Python à connaitre pour commencer la data science. Nous n'avons pas appris tout ce qu'il faut savoir et c'est fait intentionnellement afin de se concentrer sur le strict minimum qui nous permettra de commencer à réaliser des projets. Le notebook 01_07 contient des exercices sur tout ce qui a été vu concernant les bases de Python. Je vous recommande de faire tout ces exercices avant de continuer, sinon vous risquez de perdre le fil des prochains notebook qui ne seront pas autant expliqués que les précédents. Si vous rencontrez des problèmes en faisant les exercices, n'hésitez pas à chercher sur Google et poser des questions sur Discord."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}