{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Fundamentals - част V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ООП"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обектно-ориентираното програмиране (ООП) е парадигма в компютърното програмиране, при която една програмна съдържа набор от обекти, които взаимодействат помежду си. Другият вариант е програмата да съдържа последователни инструкции, които биват изпълнявани. Всеки обект е може да изпълнява действия,да обработва изпраща и приема данни.\n",
    "\n",
    "ООП дава повече гъвкавост, като прави по-лесно и безопасно манипулирането на програми. В наши дни повечето от използваните езици за програмиране са ООП езици."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Обектно-ориентираното програмиране дефинира следните концепции:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обекти – съдържат данни (полета) и функционалност - променливи и функции(моетоди). Обектите са инстанции на класовете. Обектите са самостоятелни обособени единици. Класовете спомагат за модуляризираността, което позволява на части от програмата да съответстват на отделни аспекти от ершаването на дадена задача или проблем."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Абстракция – Свойството на една програма да игнорира дадени аспекти на информацията, с която работи, като се съредоточава върху същественото."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Капсулиране – наричано също „скриване на информация“. Предотвратява директния достъп до данните на даден обект."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полиморфизъм – свойството на обектите да се държат по различен начин, зависимо от заобикалящата среда. На програмен език това значи - една и съща по име функция(метод) да има различна сигнатра(дефиниция). По този начин, една променлива в програмния текст може да съдържа различни обекти по време на изпълнение на програмата и да извиква различни методи по различно време на изпълнение."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наследяване – Организира и подпомага полиморфизма и капсулирането, като позволява да бъдат дефинирани и създавани обекти (наследници), които са наследени варианти на вече съществуващи обекти. Новите обекти могат да използват (и разширяват) съществуващата вече функционалсност дефинирана в базовия клас вече дефинираното поведение."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Класове в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Класът е дефиниция за създаване обекти (инстанции на класа). Това става със запазената дума class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "self е задължителен аргумент на методите на класа. self винаги е първият аргумент на даден метод и представлява референция към текущия обект, подобно на this в множество други езици"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a print call from inside a class method\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def func(self):\n",
    "        print('This is a print call from inside a class method')\n",
    "        \n",
    "obj = A()\n",
    "obj.func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__init__ метода е мястото където е редно да се дефинират и инициализират обектните променливи. __init__ е подобен на конструпторите в много от другите познати ООП езици, като и тук той винаги има за първи аргумент self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am object variable\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def __init__(self, var):\n",
    "        self.var = var\n",
    "        \n",
    "obj = A('I am object variable')\n",
    "print(obj.var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "Наследяване в Python се реалириза когато в скобите на класа наследник укажем кой базов клас се наследвя "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent():\n",
    "  pass\n",
    "class Child(Parent):\n",
    "  pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "__init__ метода на базовия клас не се извиква автоматично от __init__ метода на класа наследник"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creation of instance of Class Child\n"
     ]
    }
   ],
   "source": [
    "class Parent():\n",
    "  def __init__(self):\n",
    "      print('Creation of instance of Class Parent')\n",
    "class Child(Parent):\n",
    "  def __init__(self):\n",
    "      print('Creation of instance of Class Child')\n",
    "obj = Child()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "Горепосоченото може да бъде постигнато чрез използването на функцията super() която предоставя достъп до базовия клас от наследяващия го"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creation of instance of Class Parent\n",
      "Creation of instance of Class Child\n"
     ]
    }
   ],
   "source": [
    "class Parent():\n",
    "  def __init__(self):\n",
    "      print('Creation of instance of Class Parent')\n",
    "class Child(Parent):\n",
    "  def __init__(self):\n",
    "      super().__init__()\n",
    "      print('Creation of instance of Class Child')\n",
    "obj = Child()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощта на функцията super() може да достъпваме както методи така и данни дефинирани в базовия клас. За целта преди това трябва данни на базовия клас да са достъпни в класа наследник, което се постига чрез извикване на __init__ метода на басозвия клас от __init__ метода на класа наследник."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing var from the base class. var=VARIABLE-FORM-BASE-CLASS\n"
     ]
    }
   ],
   "source": [
    "class B(A):\n",
    "    def __init__(self):\n",
    "        super().__init__('VARIABLE-FORM-BASE-CLASS')\n",
    "    def func(self):\n",
    "        print('Printing var from the base class. var={}'.format(self.var))\n",
    "objB = B()\n",
    "objB.func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Специални функции в класове"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "Подобно на предефениране на функции и/или оператори в други езици за програрамиране в Python има специални функции които имат формата __име-на-функция__.Ето някой често използвани са:\n",
    "__str__\n",
    "__repr__\n",
    "__eq__\n",
    "__int__\n",
    "__bool__\n",
    "__abd__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dacia with 90 hp engine\n",
      "BMW with 200 hp engine is equal to Audi with 200 hp engine\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "This is a object of class car() with:\n",
       "        name object variable = Dacia and power object variable = 90\n",
       "        This information is only useful for developers and not the user!"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class car():\n",
    "    def __init__(self, make, power):\n",
    "        self.make = make\n",
    "        self.power = power\n",
    "    def __str__(self):\n",
    "        return '{} with {} hp engine'.format(self.make, self.power)\n",
    "    def __repr__(self):\n",
    "        return '''This is a object of class {}() with:\n",
    "        name object variable = {} and power object variable = {}\n",
    "        This information is only useful for developers and not the user!'''.format(type(self).__name__, self.make, str(self.power))\n",
    "    def __eq__(self, other):\n",
    "        return self.power == other.power\n",
    "\n",
    "car1 = car('BMW', 200)\n",
    "car2 = car('Audi', 200)\n",
    "car3 = car('Dacia', 90)\n",
    "print(car3)\n",
    "if car1 == car2:\n",
    "    print(str(car1) + ' is equal to ' + str(car2))\n",
    "car1"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}