python_oop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# class \n",
    "class MSPeak:\n",
    "    pass # null operation - placeholder\n",
    "\n",
    "# if module is imported by another program main is not used. \n",
    "# https://stackoverflow.com/questions/419163/what-does-if-name-main-do\n",
    "if __name__ == \"__main__\": \n",
    "    x = MSPeak() \n",
    "    y = MSPeak()\n",
    "    y_alias = y # reference to y \n",
    "    \n",
    "    print(x==y)\n",
    "    print(y==y_alias) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# attributes\n",
    "\n",
    "# initalize the instance right after creation\n",
    "class MSPeak:\n",
    "    def __init__(self,\n",
    "                 mz=None,\n",
    "                 intensity=None):\n",
    "        self.mz = mz\n",
    "        self.intensity = intensity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Either mz or intensity or both values are missing - could not show the peak!\n",
      "The peak can be found at mz 250 with an intensity of 600000\n"
     ]
    }
   ],
   "source": [
    "# method\n",
    "\n",
    "# initalize the instance right after creation\n",
    "class MSPeak:\n",
    "    def __init__(self,\n",
    "                 mz=None,\n",
    "                 intensity=None):\n",
    "        self.mz = mz\n",
    "        self.intensity = intensity\n",
    "    \n",
    "    def show_peak(self):\n",
    "        if self.mz and self.intensity:\n",
    "            print(\"The peak can be found at mz \" + str(self.mz) + \" with an intensity of \" + str(self.intensity))\n",
    "        else:\n",
    "            print(\"Error: Either mz or intensity or both values are missing - could not show the peak!\")\n",
    "\n",
    "if __name__ == \"__main__\": \n",
    "    # x = MSPeak(250, 60000) # using the __init__ method \"constructor\"\n",
    "    x = MSPeak()\n",
    "    x.show_peak()\n",
    "    x.mz = 250\n",
    "    x.intensity = 600000\n",
    "    x.show_peak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercise: please add the retention time to the class above! \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The peak can be found at mz 250 with an intensity of 60000 at the retention time of 300 seconds\n"
     ]
    }
   ],
   "source": [
    "### solution: Add rentention time \n",
    "\n",
    "class MSPeak:\n",
    "    def __init__(self,\n",
    "                 mz=None,\n",
    "                 intensity=None,\n",
    "                 rt=None):\n",
    "        self.mz = mz\n",
    "        self.intensity = intensity\n",
    "        self.rt = rt\n",
    "             \n",
    "    def show_peak(self):\n",
    "        if self.mz and self.intensity and self.rt:\n",
    "            print(\"The peak can be found at mz \" + str(self.mz) + \" with an intensity of \" + str(self.intensity) +\n",
    "                 \" at the retention time of \" + str(self.rt) + \" seconds\")\n",
    "        else:\n",
    "            print(\"Error: Either mz or intensity or retention time or all three values are missing - could not show the peak!\")\n",
    "            \n",
    "\n",
    "if __name__ == \"__main__\": \n",
    "    x = MSPeak(250, 60000, 300)\n",
    "    x.show_peak()\n",
    "    \n",
    "# currently still the possibilty to change the attributes without using the getter/setter methods (not encapsulated)\n",
    "# this can be prevented using private attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am public\n",
      "I am public - changed freely!\n",
      "I am protected\n"
     ]
    }
   ],
   "source": [
    "# encapsulation\n",
    "\n",
    "# public, protected, private attributes \n",
    "class A():\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.__priv = \"I am private\" # inaccessible & invisible - can only be mutated inside the class definition\n",
    "        self._prot = \"I am protected\" # should not be used outside of the class definition (unless in a subclass)\n",
    "        self.pub = \"I am public\" # used freely inside/outside class definition\n",
    "        \n",
    "    def set_private_attribute(self, __priv):\n",
    "        self.__priv = __priv\n",
    "        \n",
    "x = A()\n",
    "\n",
    "print(x.pub)\n",
    "x.pub = x.pub + \" - changed freely!\"\n",
    "print(x.pub)\n",
    "\n",
    "print(x._prot)\n",
    "\n",
    "#x.__priv\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercise: please change the MSPeak class to use private members\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The peak can be found at mz 250 with an intensity of 60000 at the retention time of 300 seconds\n",
      "250\n",
      "500\n",
      "The peak can be found at mz 500 with an intensity of 60000 at the retention time of 300 seconds\n",
      "Adding an additional peak: \n",
      "The peak can be found at mz 500 with an intensity of 60000 at the retention time of 300 seconds\n",
      "The peak can be found at mz 800 with an intensity of 80000 at the retention time of 600 seconds\n"
     ]
    }
   ],
   "source": [
    "### solution: Make members of MSPeak private \n",
    "\n",
    "# private member variables\n",
    "# data Abstraction = Data Encapsulation + Data Hiding\n",
    "# encapsulation is seen as the bundling of data with the methods that operate on that data\n",
    "# information hiding on the other hand is the principle that some internal \n",
    "# information or data is \"hidden\", so that it can't be accidentally changed\n",
    "\n",
    "class MSPeak:\n",
    "    def __init__(self,\n",
    "                 mz=None,\n",
    "                 intensity=None,\n",
    "                 rt=None):\n",
    "        self.__mz = mz\n",
    "        self.__intensity = intensity\n",
    "        self.__rt = rt\n",
    "    \n",
    "    def set_mz(self, mz):\n",
    "        self.__mz = mz\n",
    "    \n",
    "    def get_mz(self):\n",
    "        return self.__mz\n",
    "\n",
    "    def set_intensity(self, intensity):\n",
    "        self.__intensity = intensity\n",
    "    \n",
    "    def get_intensity(self):\n",
    "        return self.__intensity\n",
    "    \n",
    "    def set_rt(self, rt):\n",
    "        self.__rt = rt\n",
    "    \n",
    "    def get_rt(self):\n",
    "        return self.__rt\n",
    "             \n",
    "    def show_peak(self):\n",
    "        if self.__mz and self.__intensity and self.__rt:\n",
    "            print(\"The peak can be found at mz \" + str(self.__mz) + \" with an intensity of \" + str(self.__intensity) +\n",
    "                 \" at the retention time of \" + str(self.__rt) + \" seconds\")\n",
    "        else:\n",
    "            print(\"Error: Either mz or intensity or retention time or all three values are missing - could not show the peak!\")\n",
    "            \n",
    "\n",
    "if __name__ == \"__main__\": \n",
    "    x = MSPeak(250, 60000, 300)\n",
    "    x.show_peak()\n",
    "    # x.mz(300) -> leads to an error, since variable is private\n",
    "    print(x.get_mz())\n",
    "    x.set_mz(500)\n",
    "    print(x.get_mz())\n",
    "    x.show_peak()\n",
    "    \n",
    "    print(\"Adding an additional peak: \")\n",
    "    y = MSPeak(800, 80000, 600)\n",
    "    \n",
    "    for peak in [x,y]:\n",
    "        peak.show_peak()\n",
    "        \n",
    "# getter and setter can be usually provided automatically by an IDE for every member variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This class is about pet animals!\n",
      "This class is about man's best friends!\n",
      "This class is about all kinds of cats!\n"
     ]
    }
   ],
   "source": [
    "# class methods vs. static methods - inheritance\n",
    "\n",
    "class Pet: # base class\n",
    "    _class_info = \"pet animals\"\n",
    "\n",
    "    def about(self):\n",
    "        print(\"This class is about \" + self._class_info + \"!\")   \n",
    "\n",
    "class Dog(Pet):\n",
    "    _class_info = \"man's best friends\" # overload\n",
    "\n",
    "class Cat(Pet):\n",
    "    _class_info = \"all kinds of cats\" # overload\n",
    "    \n",
    "p = Pet()\n",
    "p.about()\n",
    "d = Dog()\n",
    "d.about()\n",
    "c = Cat()\n",
    "c.about()\n",
    "\n",
    "# works, but from the design point of few it is bad to always have to make\n",
    "# a class object to know what kind of class it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This class is about pet animals!\n",
      "This class is about pet animals!\n",
      "This class is about pet animals!\n"
     ]
    }
   ],
   "source": [
    "# class methods vs. static methods - inheritance\n",
    "\n",
    "class Pet: # base class\n",
    "    _class_info = \"pet animals\"\n",
    "\n",
    "    @staticmethod\n",
    "    def about():\n",
    "        print(\"This class is about \" + Pet._class_info + \"!\")   \n",
    "    \n",
    "\n",
    "class Dog(Pet):\n",
    "    _class_info = \"man's best friends\" # overload\n",
    "    \n",
    "    #@staticmethod\n",
    "    #def about(): # overlad\n",
    "    #    print(\"This class is about \" + Dog._class_info + \"!\") \n",
    "\n",
    "class Cat(Pet):\n",
    "    _class_info = \"all kinds of cats\" # overload\n",
    "    \n",
    "Pet.about()\n",
    "Dog.about()\n",
    "Cat.about()\n",
    "\n",
    "# no way to differentate what kind of class it really is! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This class is about pet animals!\n",
      "This class is about man's best friends!\n",
      "This class is about all kinds of cats!\n"
     ]
    }
   ],
   "source": [
    "# class methods vs. static methods - inheritance\n",
    "class Pet: # base class\n",
    "    _class_info = \"pet animals\"\n",
    "\n",
    "    @classmethod\n",
    "    def about(cls):\n",
    "        print(\"This class is about \" + cls._class_info + \"!\")   \n",
    "    \n",
    "class Dog(Pet):\n",
    "    _class_info = \"man's best friends\" # overload\n",
    "\n",
    "class Cat(Pet):\n",
    "    _class_info = \"all kinds of cats\" # overload\n",
    "    \n",
    "Pet.about()\n",
    "Dog.about()\n",
    "Cat.about()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##--additional information--##\n",
    "\n",
    "# methods\n",
    "# usually the methods are not defined outside of the class, but inside as a member function.\n",
    " \n",
    "def show_peak(obj):\n",
    "    print(\"The peak can be found at mz \" + str(obj.mz) + \" with an intensity of \" + str(obj.intenstiy))\n",
    "\n",
    "class MSPeak:\n",
    "    detected_peak = show_peak\n",
    "\n",
    "if __name__ == \"__main__\": \n",
    "    x = MSPeak()\n",
    "    x.mz = 300\n",
    "    x.intenstiy = 10000\n",
    "    x.detected_peak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##--additional information--##\n",
    "\n",
    "# adding a destructor but memory management is usually done by python directly - called: garbage collection\n",
    "class MSPeak:\n",
    "    def __init__(self,\n",
    "                 mz=None,\n",
    "                 intensity=None,\n",
    "                 rt=None):\n",
    "        self.__mz = mz\n",
    "        self.__intensity = intensity\n",
    "        self.__rt = rt\n",
    "        \n",
    "    def __del__(self):\n",
    "        print(\"The peak has been deleted\")\n",
    "    \n",
    "    def set_mz(self, mz):\n",
    "        self.__mz = mz\n",
    "    \n",
    "    def get_mz(self):\n",
    "        return self.__mz\n",
    "\n",
    "    def set_intensity(self, intensity):\n",
    "        self.__intensity = intensity\n",
    "    \n",
    "    def get_intensity(self):\n",
    "        return self.__intensity\n",
    "             \n",
    "    def show_peak(self):\n",
    "        if self.__mz and self.__intensity and self.__rt:\n",
    "            print(\"The peak can be found at mz \" + str(self.__mz) + \" with an intensity of \" + str(self.__intensity) +\n",
    "                 \" at the retention time of \" + str(self.__rt) + \" seconds\")\n",
    "        else:\n",
    "            print(\"Error: Either mz or intensity or retention time or all three values are missing - could not show the peak!\")\n",
    "            \n",
    "\n",
    "if __name__ == \"__main__\": \n",
    "    x = MSPeak(250, 60000, 300)\n",
    "    y = MSPeak(800, 80000, 600)\n",
    "    \n",
    "    for peak in [x,y]:\n",
    "        peak.show_peak()\n",
    "        \n",
    "    z = x\n",
    "    del x\n",
    "    del z\n",
    "    # x.show_peak() -> x is not defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##--additional information--##\n",
    "\n",
    "# use static method to count instances without creating one\n",
    "class MSPeak:\n",
    "    __counter = 0\n",
    "    \n",
    "    def __init__(self):\n",
    "        type(self).__counter += 1\n",
    "    \n",
    "    @staticmethod # does not need a reference to an instance!\n",
    "    def instanceCount():\n",
    "        return MSPeak.__counter\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    print(MSPeak.instanceCount())\n",
    "    x = MSPeak()\n",
    "    print(x.instanceCount())\n",
    "    print(MSPeak.instanceCount())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "1500\n",
      "-------\n",
      "800\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "##--additional information--##\n",
    "\n",
    "# python usually properties are used instead of private variables \n",
    "class P:\n",
    "\n",
    "    def __init__(self,x): # member is public! \n",
    "        self.set_x(x)\n",
    "\n",
    "    def get_x(self):\n",
    "        return self.__x\n",
    "\n",
    "    def set_x(self, x):\n",
    "        if x < 0:\n",
    "            self.__x = 0\n",
    "        elif x > 1000:\n",
    "            self.__x = 1000\n",
    "        else:\n",
    "            self.__x = x\n",
    "            \n",
    "p = P(1100)\n",
    "print(p.get_x())\n",
    "p.x = 1500 # it is still possible to reset the variable to a value higher than 1000! \n",
    "print(p.x)\n",
    "print(\"-------\")\n",
    "    \n",
    "class P:\n",
    "\n",
    "    def __init__(self,x):\n",
    "        self.x = x\n",
    "\n",
    "    @property #python way! \n",
    "    def x(self):\n",
    "        return self.__x\n",
    "\n",
    "    @x.setter\n",
    "    def x(self, x):\n",
    "        if x < 0:\n",
    "            self.__x = 0\n",
    "        elif x > 1000:\n",
    "            self.__x = 1000\n",
    "        else:\n",
    "            self.__x = x\n",
    "            \n",
    "p = P(800)\n",
    "print(p.x)\n",
    "p.x = 1500 # can still set the variable public, but with specific constrains! \n",
    "print(p.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "##--additional information--##\n",
    "\n",
    "class OurClass:\n",
    "\n",
    "    def __init__(self, a):\n",
    "        self.OurAtt = a\n",
    "\n",
    "\n",
    "x = OurClass(10)\n",
    "print(x.OurAtt)\n",
    "\n",
    "# ------- #\n",
    "\n",
    "class OurClass:\n",
    "\n",
    "    def __init__(self, a):\n",
    "        self.OurAtt = a\n",
    "\n",
    "    @property\n",
    "    def OurAtt(self):\n",
    "        return self.__OurAtt\n",
    "\n",
    "    @OurAtt.setter\n",
    "    def OurAtt(self, val):\n",
    "        if val < 0:\n",
    "            self.__OurAtt = 0\n",
    "        elif val > 1000:\n",
    "            self.__OurAtt = 1000\n",
    "        else:\n",
    "            self.__OurAtt = val\n",
    "\n",
    "\n",
    "x = OurClass(10)\n",
    "print(x.OurAtt)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Doctor object at 0x7fb812c7eac0> <class '__main__.Doctor'>\n",
      "<__main__.Surgeon object at 0x7fb812c7e3a0> <class '__main__.Surgeon'>\n",
      "Hi, my name is Dr. Hans\n"
     ]
    }
   ],
   "source": [
    "##--additional information--##\n",
    "\n",
    "class Doctor:\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def say_hello(self):\n",
    "        print(\"Hi, my name is Dr. \" + self.name)\n",
    "        \n",
    "class Surgeon(Doctor):\n",
    "    pass\n",
    "\n",
    "x = Doctor(\"Peter\")\n",
    "y = Surgeon(\"Hans\")\n",
    "\n",
    "print(x, type(x))\n",
    "print(y, type(y))\n",
    "\n",
    "y.say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, my name is Dr. Peter\n",
      "Everything will be okay! \n",
      "Hans takes care of you!\n"
     ]
    }
   ],
   "source": [
    "##--additional information--##\n",
    "class Doctor:\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def say_hello(self):\n",
    "        print(\"Hi, my name is Dr. \" + self.name)\n",
    "        \n",
    "class Surgeon(Doctor):\n",
    "    \n",
    "    def say_hello(self): # method override\n",
    "        print(\"Everything will be okay! \") \n",
    "        print(self.name + \" takes care of you!\")\n",
    "\n",
    "x = Doctor(\"Peter\")\n",
    "y = Surgeon(\"Hans\")\n",
    "\n",
    "x.say_hello()\n",
    "y.say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a class attribute!\n",
      "I am a class attribute!\n",
      "I am a class attribute!\n",
      "-------------------\n",
      "This creates a new instance attribute for x\n",
      "I am a class attribute!\n",
      "I am a class attribute!\n",
      "-------------------\n",
      "This creates a new instance attribute for x\n",
      "This is changing the class attribute\n",
      "This is changing the class attribute\n",
      "-------------------\n",
      "{'a': 'This creates a new instance attribute for x'}\n",
      "-------------------\n",
      "{'__module__': '__main__', 'a': 'This is changing the class attribute', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}\n",
      "-------------------\n",
      "{'__module__': '__main__', 'a': 'This is changing the class attribute', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "##--additional information--##\n",
    "\n",
    "# class attributes \n",
    "class A:\n",
    "    a = \"I am a class attribute!\"\n",
    "\n",
    "x = A()\n",
    "y = A()\n",
    "print(x.a)\n",
    "print(y.a)\n",
    "print(A.a)\n",
    "print(\"-------------------\")\n",
    "\n",
    "x.a = \"This creates a new instance attribute for x\"\n",
    "\n",
    "print(x.a)\n",
    "print(y.a)\n",
    "print(A.a)\n",
    "print(\"-------------------\")\n",
    "\n",
    "A.a = \"This is changing the class attribute\"\n",
    "\n",
    "print(x.a)\n",
    "print(y.a)\n",
    "print(A.a)\n",
    "print(\"-------------------\")\n",
    "\n",
    "# Python's class attributes and object attributes are stored in separate dictionaries\n",
    "print(x.__dict__) # instances dictionary\n",
    "print(\"-------------------\")\n",
    "print(x.__class__.__dict__) # class dictrionary\n",
    "print(\"-------------------\")\n",
    "print(A.__dict__)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}