1.5_lesson5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More structureeFunction & Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Open a file in following steps to get the file string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"docs/INSTALL.md\",mode=\"r\",errors=\"ignore\")\n",
    "\n",
    "file_str = f.read()\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Environment Installation\n",
      "\n",
      "This is a brief reference to environment installation.\n",
      "\n",
      "## Linux Node\n",
      "\n",
      "H\n"
     ]
    }
   ],
   "source": [
    "print(file_str[:100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case we want to open up other files, you can do the above steps.\n",
    "\n",
    "Try open \"docs/pre_checklist.md\" and get its string.\n",
    "\n",
    "So you copy+ paste, or you just modify the code above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = open(\"docs/pre_checklist.md\",mode=\"r\",errors=\"ignore\")\n",
    "\n",
    "file_str = f.read()\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then you feel like opening file is a pretty simple task, I shouldn't code that much for such rountine performance. So here we have function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def read_file(path):\n",
    "    f = open(path,mode=\"r\",errors=\"ignore\")\n",
    "\n",
    "    file_str = f.read()\n",
    "\n",
    "    f.close()\n",
    "    \n",
    "    return file_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how we wrap up a function, it's a neat action we can call, to do a bunch of actions in a simple way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "read_file(\"docs/pre_checklist.md\") # You just boil down several lines of action into one!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pass function as variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "def today():\n",
    "    \"\"\"\n",
    "    A function to return the datetime format for the time now\n",
    "    Pass no arguments\n",
    "    \"\"\"\n",
    "    return datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function today in module __main__:\n",
      "\n",
      "today()\n",
      "    A function to return the datetime format for the time now\n",
      "    Pass no arguments\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.today>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "today"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "get_now = today\n",
    "\n",
    "get_now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2018, 6, 24, 10, 56, 35, 155647)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_now() # call the function get_now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "now_time = today() \n",
    "\n",
    "now_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wirte a function square, that will return the square of a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    \"\"\"\n",
    "    x:input number\n",
    "    return: square of number x\n",
    "    \"\"\"\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(square,range(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simpler 1 liner: lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x:x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x:x**2,range(6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sq = lambda x:x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sq(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"leng\" is the only arguement here, its default value is 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_line(leng = 60):\n",
    "    \"\"\"\n",
    "    leng:length of the line, default 60\n",
    "    return: a separation line\n",
    "    \"\"\"\n",
    "    return \"=\"*leng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'============================================================'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print_line()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'========================================'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print_line(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A function to return exact time one day ago (might involve some google on \"python datetime yesterday\")\n",
    "* Write a function, return the time elapsed between 2 datetime object inputs\n",
    "* A function to print image in website, input is image url, output is a string looks like following: <img src='imageurlhere' height=200 width=200> , you can use real image url as input, will be fun"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write me a function, every time I call, tell me the time now\n",
    "\n",
    "But from the second time I call the function,it will tell me the time, and also the time elapsed from the last time I called the function.\n",
    "\n",
    "This is a useful function, to calculate the time taken between steps for your future python work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, you either find how python loosely define global variable (a variable that can be used within or without a function), or you will stuck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anyway, there is a neat way to do such job, to keep track on certain attributes.\n",
    "\n",
    "### To amplify this misery, try another question\n",
    "\n",
    "Like driving a car, we run *put_on_seat_belt()* to make variable *seat_belt_on = True*,  \n",
    "\n",
    "We want start the car, write a function *start()*, that will return car is started(only if the seat_belt_on is True).  When the car was started the speed will be 20. So when the car speed is above 20, start() wil do nothing.\n",
    "\n",
    "Like a car goes at 20 miles/ hour from starting, if we run function *crank_up_speed(10)*, it will run at 30 miles/hour, if we run *cranc_up_speed(15)*, it will run at 45 miles/ hour. If we run function *brake()*, it will return \"car stopped\" , but if the speed goes beyond 40, it will return \"car stopped with ABS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class car:\n",
    "    def __init__(self,speed_limit):\n",
    "        \"\"\"\n",
    "        a car class\n",
    "        \"\"\"\n",
    "        # __init__ is initializing function\n",
    "        # it's called, when you run a = car(150)\n",
    "        # 150 is the parameter passed as arg speed_limit\n",
    "        self.seat_belt_on = False\n",
    "        self.speed = 0\n",
    "        self.speed_limit = speed_limit\n",
    "        \n",
    "    def put_on_seat_belt(self):\n",
    "        self.seat_belt_on = True\n",
    "        \n",
    "    def start(self):\n",
    "        if self.seat_belt_on:\n",
    "            if self.speed < 20:\n",
    "                self.speed = 20\n",
    "                return \"car is started\"\n",
    "        else:\n",
    "            return \"please put on seat belt\"\n",
    "        \n",
    "    def cranc_up_speed(self,x):\n",
    "        assert x>0,\"speed up should be positive\"\n",
    "        \n",
    "        self.speed += int(x)\n",
    "        self.speed = min([self.speed, self.speed_limit]) # shall not pass limit\n",
    "        \n",
    "        return \"The speed now is %s\"%(self.speed)\n",
    "    \n",
    "    def brake(self):\n",
    "        rt = \"car stopped\"\n",
    "        if self.speed >40:\n",
    "            rt += \" with ABS\"\n",
    "        self.speed = 0\n",
    "        return rt\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "car1 = car(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "print(car1.speed_limit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(car1.seat_belt_on)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(car1.speed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'please put on seat belt'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(car1.speed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "car1.put_on_seat_belt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'car is started'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print(car1.speed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car speed now is  35\n",
      "car speed now is  50\n",
      "car speed now is  65\n",
      "car speed now is  80\n",
      "car speed now is  95\n",
      "car speed now is  110\n",
      "car speed now is  125\n",
      "car speed now is  140\n",
      "car speed now is  155\n",
      "car speed now is  170\n",
      "car speed now is  185\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n",
      "car speed now is  200\n"
     ]
    }
   ],
   "source": [
    "for i in range(20):\n",
    "    car1.cranc_up_speed(15)\n",
    "    print(\"car speed now is \",car1.speed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'car stopped with ABS'"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.brake()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "car is a class, car1 is an obeject of class car."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.car'>\n"
     ]
    }
   ],
   "source": [
    "print(type(car1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This intuitive way of programing an object is called objective oriented programing(oop), small wonder oop is heavily used in gaming industry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}