OOP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall our first session: _Everthing in python is an object_\n",
    "\n",
    "and,\n",
    "\n",
    "Objects have three properites\n",
    "- id\n",
    "- value\n",
    "- type\n",
    "\n",
    "A few characteristics of OOP/D:\n",
    "\n",
    "- Encapsulation\n",
    "- Polymorphism\n",
    "- Inheritance\n",
    "\n",
    "Encapsulation is not just about data: we define operations on this data as well (and if you want to sound  sophisticated, refer to _attributes_ and _methods_, rather than data and operations)\n",
    "\n",
    "But! This is a class on Python, not object oriented programming\n",
    "\n",
    "so...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "Classes encapsulate ~~data~~ attributes and ~~operations~~ methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the simplest possible class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## empty class\n",
    "class Foo(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general syntax is as follows:\n",
    "\n",
    "<!--![Class Syntax](figs\\classdefinition.png)-->\n",
    "<img src=\"figs\\classdefinition.png\" alt=\"class syntax\" width=\"300\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating an object of class Foo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(f) : <class '__main__.Foo'>\n",
      "  id(f) : 2033097287440\n"
     ]
    }
   ],
   "source": [
    "f = Foo() ## this is the (default) constructor for Foo\n",
    "utils.printProps((type, id), \"f\", f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What attributes does class Foo have?\n",
    "\n",
    "_Hey!_ waitaminute...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(Foo) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<__main__.Foo object at 0x000001D95E0AA710>'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Foo at 0x1d95e0aa9b0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__class__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's start adding a few attributes. \n",
    "\n",
    "This (imho) is where we violate the spirit of OOD & P!!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "Foo.bar = 'yo!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'bar']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(Foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yo!\n"
     ]
    }
   ],
   "source": [
    "print(Foo.bar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Foo object at 0x000001D95DFEACF8>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'bar']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Foo()\n",
    "print(f)\n",
    "dir(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yo!'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.bar = \"huh?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yo! huh?\n"
     ]
    }
   ],
   "source": [
    "print(Foo.bar, f.bar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yo!\n"
     ]
    }
   ],
   "source": [
    "g = Foo()\n",
    "print(g.bar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.b = \"fb\"\n",
    "g.c = \"gc\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fb:  fb\n",
      "fbar:  huh?\n",
      "gc:  gc\n",
      "gbar:  yo!\n",
      "fizbang\n",
      "huh?\n",
      "fizbang\n"
     ]
    }
   ],
   "source": [
    "print(\"fb: \", f.b)\n",
    "#print(\"fc: \", f.c)\n",
    "print(\"fbar: \", f.bar)\n",
    "#print(\"gb: \", g.b)\n",
    "print(\"gc: \", g.c)\n",
    "print(\"gbar: \", g.bar)\n",
    "\n",
    "Foo.bar = \"fizbang\"\n",
    "print(Foo.bar)\n",
    "print(f.bar)\n",
    "print(g.bar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now ... methods!\n",
    "\n",
    "Thankfully, it's a lot more difficult to define class methods whereever/whenever we want to!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-40-97b9334c7b7b>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-40-97b9334c7b7b>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def Foo.baz(self, p):\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def Foo.baz(self, s):\n",
    "    print(\"Hello, world!\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello,  world\n"
     ]
    }
   ],
   "source": [
    "class Foo(object):\n",
    "    def baz(self, s):\n",
    "        print(\"hello, \", s)\n",
    "        \n",
    "h = Foo()\n",
    "h.baz(\"world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello,  world\n",
      "\n",
      "<__main__.Foo object at 0x000001D95E0AAE10>\n",
      "\n",
      "type(self) : <class '__main__.Foo'>\n",
      "  id(self) : 2033097289232\n",
      "\n",
      "type(h) : <class '__main__.Foo'>\n",
      "  id(h) : 2033097289232\n",
      "\n",
      "type(baz) : <class 'function'>\n",
      "  id(baz) : 2033097263576\n"
     ]
    }
   ],
   "source": [
    "class Foo(object):\n",
    "    def baz(self, s):\n",
    "        print(\"hello, \", s)\n",
    "        print()\n",
    "        print(self)\n",
    "        print()\n",
    "        utils.printProps((type, id), \"self\", self)\n",
    "        \n",
    "h = Foo()\n",
    "h.baz(\"world\")\n",
    "print()\n",
    "utils.printProps((type, id), \"h\", h)\n",
    "print()\n",
    "utils.printProps((type, id), \"baz\", Foo.baz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_self_ is the object that called the method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's look at initializing objects with values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello,  world\n"
     ]
    }
   ],
   "source": [
    "class Foo(object):\n",
    "    \n",
    "    def __init__(self, s):\n",
    "        self.str = s ## springs into existence when referenced :-(\n",
    "    \n",
    "    def baz(self):\n",
    "        print(\"hello, \", self.str)\n",
    "        \n",
    "i = Foo(\"world\")\n",
    "i.baz()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello,  world\n",
      "class Foo, object 2033097925688, s world\n"
     ]
    }
   ],
   "source": [
    "## add a utility function\n",
    "class Foo(object):\n",
    "    \n",
    "    def __init__(self, s):\n",
    "        self.str = s ## springs into existence when referenced :-(\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"class Foo, object {}, s {}\".format(id(self), self.str)\n",
    "    \n",
    "    def baz(self):\n",
    "        print(\"hello, \", self.str)\n",
    "        \n",
    "i = Foo(\"world\")\n",
    "i.baz()\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework\n",
    "\n",
    "Define your own Point class, that has two attributes: $x$ and $y$. Implement methods that \n",
    "- returns the euclidean distance between the two points \n",
    "- sum two points and returns the result\n",
    "\n",
    "Can you generalize this to $n$-dimensional space?"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}