OOP Python Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programming (OOP) Python:\n",
    "\n",
    "### Author: Samyakh Tukra (2017) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay so starting with OOP is actually quite simple.... just follow the example shown below where I recreate a classic programming language called LOGO which was used to teach programming to me in CMA (my school in Gujarat India). The idea was that commands are given to the turtle which moved and the turtle would print out a trajectory of its movement.\n",
    "\n",
    "So let's get started......"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before I do so, it is important to understand some terminology! consider the following definition/script:\n",
    "Objects are representation of the real world i.e. car, dog, bike etc. There are 2 main characteristics of an object: data and behaviour.\n",
    "\n",
    "e.g. Object = Car, this object has its own data we want to use i.e. no of wheels, no of doors, max acceleration, seating capacity and etc (attributes its made of). It also has behaviour: drive, stop, accelerate (i.e. things it does).\n",
    "\n",
    "Therefore data are known as attributes  (i.e. things it comprises of) and behaviour is known as methods (things it can do). A Class is a blue print from with this would be created i.e. a category. A class car can have different objects like tesla, bmw and mercedes.\n",
    "\n",
    "##### Within a class we can assign attributes which are common to all objects.\n",
    "for example, the objects tesla, bmw and mercedes will have the same attributes(data needed to define them). and perhaps the same methods (things they can do) the only thing that varies is the actual value/capacity at which they can be done... i.e. max speed of bmw may be 155mph whereas a tesla may do 250mph.\n",
    "\n",
    "##### thus Classes come first and then objects, which are instances of classes. i.e. Car is the class, tesla model s is the object. Or Class= vegetables and object = okra.\n",
    "\n",
    "A class is simply used to group data and functions in a category (makes cleaner looking code.... highly applicable in gaming) its a blue print... consider the example below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I am going to create a vehicle class\n",
    "''' remember classes have attributes(properties) and methods (functions) and\n",
    "objects are instances of classes.'''\n",
    "\n",
    "class Vehicle: # to define a class simply use the class function followed by class name\n",
    "    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):\n",
    "        # init is your initialiser, it initialises the input arguements needed for your attributes\n",
    "        # self is always used as the first argument, this is so that when we call objects\n",
    "        # objects can refer to these attributes as part of the class!\n",
    "        self.number_of_wheels = number_of_wheels\n",
    "        self.type_of_tank = type_of_tank # this will essentially be the value needed\n",
    "        self.seating_capacity = seating_capacity\n",
    "        self.maximum_velocity = maximum_velocity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "tesla_model_s = Vehicle(4, 'electric', 5, 250) # defining a tesla model object\n",
    "# to define an object we define it using the class Vehicle(attributes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we understand the basics..... let's go deeper and try to recreate the classic game logo and see how that works with basic OOP\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first import the necessary libraries:\n",
    "import sys, os, math, random, functools\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as pp\n",
    "import matplotlib.animation as anim\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d15a7b5cf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' So we need 2 classes, 1 being the turtle which will hold position, pen, angle\n",
    "and movement ofcourse since it will respond to our commands. 2 being the Terarrium\n",
    "which will be important for hilding the image of what we draw and displaying the\n",
    "trajectory.'''\n",
    "\n",
    "class Turtle(object):\n",
    "    # before the init function we can define the class attributes which are common to all instances i.e. like a global variable\n",
    "    deg = math.pi/180.0\n",
    "      # every class needs to begin with an initializer! this is to state all the variables the following methods will use:\n",
    "    def __init__(self,Terrarium):\n",
    "        self.pos = (0,0) # start with the initial position of the origin\n",
    "        self.angle = 0 \n",
    "        self.pen= True # pen to down!\n",
    "        self.axes= Terrarium.axes\n",
    "        '''at first instance just state the functions (i.e. methods) and fill them with pass so that they are python legal\n",
    "        fill the methods with the relevant instructions later\n",
    "        note all methods( functions) take their first argument as \"self\" this is to refer back to the instnce of which we call a method'''\n",
    "    def forward(self,distance): # forward movement\n",
    "        new_position= (self.pos[0] + distance* math.cos(self.deg*self.angle),\n",
    "                       self.pos[1] + distance * math.sin(self.deg*self.angle))\n",
    "        '''Using trignometry, [0] is the x coordinate and [1] is the y coordinate if the angle is in degrees I multiply by a constant\n",
    "        defined by the class attribute deg to turn it into radians.'''\n",
    "        if self.pen: # if pen is down we will draw\n",
    "            Line= pp.Line2D((self.pos[0],new_position[0]),(self.pos[1],new_position[1])) \n",
    "            self.axes.add_line(Line)\n",
    "                  \n",
    "        self.pos= new_position\n",
    "            \n",
    "    def back(self,distance):\n",
    "        self.forward(-distance)\n",
    "            \n",
    "    def left(self,angle): # moving to the left at an angle\n",
    "        self.angle = (self.angle + angle) % 360 # I may want to input a new angle so I replace the original\n",
    "            \n",
    "    def right(self,angle): # moving to the right at an angle\n",
    "        self.angle = (self.angle - angle) % 360\n",
    "            \n",
    "    def pen_on(self):\n",
    "        self.pen = True # I want to draw the trajectory\n",
    "            \n",
    "    def pen_off(self):\n",
    "        self.pen = False     # I don't want to draw the trajectory\n",
    "\n",
    "\n",
    "\n",
    "class Terarrium(object):\n",
    "    def __init__(self):\n",
    "            # Now to actually implement the drawing:\n",
    "        self.figure = pp.figure(figsize=(10,10))\n",
    "        self.axes= pp.axes()\n",
    "           \n",
    "            # to get rid of the axis lines:\n",
    "        self.axes.set_xticks([])\n",
    "        self.axes.set_yticks([])\n",
    "\n",
    "        for spine in ['bottom','top','left','right']:\n",
    "            self.axes.spines[spine].set_color('0.9')\n",
    "\n",
    "\n",
    "            # Putting the rescaling in a separate method:\n",
    "    def rescale(self):\n",
    "        self.axes.axis('scaled')\n",
    "\n",
    "        xmin,xmax,ymin,ymax = self.axes.axis()\n",
    "        dx= (xmax - xmin)/50\n",
    "        self.axes.axis([xmin-dx,xmax+dx,ymin-dx,ymax+dx])\n",
    "            \n",
    "T= Terarrium()\n",
    "\n",
    "turtle1= Turtle(T)# where the turtle lives\n",
    "\n",
    "# Let's try it out\n",
    "turtle1.forward(100)\n",
    "turtle1.left(90) #degrees\n",
    "turtle1.forward(150)\n",
    "turtle1.right(45) #degrees\n",
    "turtle1.back(100)\n",
    "turtle1.left(25)\n",
    "turtle1.forward(50)\n",
    "turtle1.left(45)\n",
    "\n",
    "T.rescale()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So above we covered two topics: Abstraction (creating classes and implementing them) and Encapsulation (Grouping data members and methods together)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now Let's look at Inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''inheritance is where we build more specialised objects from simpler ones so\n",
    "essentially we can copy and paste our simple classes and add new stuff to it without\n",
    "having to repeatedly create them again and again'''\n",
    "\n",
    "# consider the following example:\n",
    "\n",
    "def polyspi(t,side,angle):\n",
    "    if side:\n",
    "        t.forward(side)\n",
    "        t.right(angle)\n",
    "        polyspi(t,side-2,angle)\n"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}