01_02 Calculator Sandbox.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Start Example III-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from os import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# the bar bones calculator\n",
    "# Step One, get numbers and symbols from user\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = input(\"\")\n",
    "print(user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# add procedural function\n",
    "def convert_user_input(value):\n",
    "    return value\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = convert_user_input(input(\"\"))\n",
    "print(user_input, type(user_input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End Example III-2\n",
    "___\n",
    "\n",
    "# Start Example III-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# add in some logic for converting to number\n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(value=='+' or value=='-' or value=='/' or value=='*' or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = convert_user_input(input(\"\"))\n",
    "print(user_input, type(user_input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End Example III-4\n",
    "_____\n",
    "\n",
    "# Start Example III-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# start adding in the evaluation queue \n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(value=='+' or value=='-' or value=='/' or value=='*' or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# make the program functional, but not pythonic\n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(value=='+' or value=='-' or value=='/' or value=='*' or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)\n",
    "    \n",
    "    \n",
    "    if len(eval_queue)>=3 and \\\n",
    "    (eval_queue[-1]=='+' or eval_queue[-1]=='-' or eval_queue[-1]=='/' or eval_queue[-1]=='*'):\n",
    "            \n",
    "        op = eval_queue.pop()\n",
    "        result = op\n",
    "        \n",
    "        v2 = eval_queue.pop()\n",
    "        v1 = eval_queue.pop()\n",
    "        if   op=='-':\n",
    "            result = v1-v2\n",
    "        elif op=='+':\n",
    "            result = v1+v2\n",
    "        elif op=='*':\n",
    "            result = v1*v2\n",
    "        elif op=='/':\n",
    "            result = v1/v2\n",
    "            \n",
    "        eval_queue.append(result)\n",
    "        \n",
    "    print(eval_queue)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def isoperation(value):\n",
    "    if(value=='+' or value=='-' or value=='/' or value=='*'):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(isoperation(value) or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "    \n",
    "def perform_operation(op,vals):\n",
    "    \n",
    "    if   op=='-':\n",
    "        return vals[0]-vals[1]\n",
    "    elif op=='+':\n",
    "        return vals[0]+vals[1]\n",
    "    elif op=='*':\n",
    "        return vals[0]*vals[1]\n",
    "    elif op=='/':\n",
    "        return vals[0]/vals[1]\n",
    "    \n",
    "    return op\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)\n",
    "    \n",
    "    \n",
    "    if isoperation(eval_queue[-1]):\n",
    "            \n",
    "        op = eval_queue.pop()\n",
    "        result = op\n",
    "        \n",
    "        v2 = eval_queue.pop()\n",
    "        v1 = eval_queue.pop()\n",
    "        \n",
    "        result = perform_operation(op,(v1,v2))\n",
    "        eval_queue.append(result)\n",
    "        \n",
    "    print(eval_queue)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "operations_list = ['+','-','*','/','^']\n",
    "# add some functionality and clean up\n",
    "def isoperation(value):\n",
    "    if value in operations_list:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(isoperation(value) or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "    \n",
    "def perform_operation(op,vals):\n",
    "    \n",
    "    if   op=='-':\n",
    "        return vals[0]-vals[1]\n",
    "    elif op=='+':\n",
    "        return vals[0]+vals[1]\n",
    "    elif op=='*':\n",
    "        return vals[0]*vals[1]\n",
    "    elif op=='/':\n",
    "        return vals[0]/vals[1]\n",
    "    elif op=='^':\n",
    "        return vals[0]**vals[1]\n",
    "    \n",
    "    return op\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)\n",
    "    \n",
    "    if isoperation(eval_queue[-1]):\n",
    "            \n",
    "        op = eval_queue.pop()\n",
    "        result = op\n",
    "        \n",
    "        v2 = eval_queue.pop()\n",
    "        v1 = eval_queue.pop()\n",
    "        \n",
    "        result = perform_operation(op,(v1,v2))\n",
    "        eval_queue.append(result)\n",
    "        \n",
    "    print(eval_queue)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# End Example III-6\n",
    "\n",
    "\n",
    "# END OF WEEK ONE EXAMPLE\n",
    "\n",
    "___\n",
    "\n",
    "# START WEEK TWO, EXAMPLE\n",
    "- lambdas\n",
    "- function passing\n",
    "- classes\n",
    "- exceptions\n",
    "- files\n",
    "- comprehensions\n",
    "\n",
    "\n",
    "____\n",
    "# Start Example II-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator prompt\n",
      "5\n",
      "[5.0]\n",
      "6\n",
      "[5.0, 6.0]\n",
      "+\n",
      "[11.0]\n",
      "q\n",
      "[11.0, 'q']\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import operator as oper\n",
    "# add dictionary of operations and function passing\n",
    "operations_list = {'+':oper.add,\n",
    "                   '-':oper.sub,\n",
    "                   '*':oper.mul,\n",
    "                   '/':oper.truediv,\n",
    "                   '^':oper.pow,\n",
    "                   '%':oper.mod,\n",
    "                  }\n",
    "def isoperation(value):\n",
    "    if value in operations_list.keys():\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def isfloat(value):\n",
    "    try:\n",
    "        tmp = float(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "def convert_user_input(value):\n",
    "    if isfloat(value):\n",
    "        return float(value)\n",
    "    \n",
    "    elif(isoperation(value) or value=='q'):\n",
    "        return value # leave as is and interpret operation later\n",
    "    \n",
    "def perform_operation(op,vals):\n",
    "    if isoperation(op):\n",
    "        func = operations_list[op]\n",
    "        return func(vals[0],vals[1])\n",
    "    \n",
    "    return op\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)\n",
    "    \n",
    "    if isoperation(eval_queue[-1]):\n",
    "            \n",
    "        result = eval_queue.pop()\n",
    "        \n",
    "        v2 = eval_queue.pop()\n",
    "        v1 = eval_queue.pop()\n",
    "        \n",
    "        result = perform_operation(result,(v1,v2))\n",
    "        eval_queue.append(result)\n",
    "        \n",
    "    print(eval_queue)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End Example II-2\n",
    "____\n",
    "\n",
    "# Start Example II-4\n",
    "Make it object oriented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator prompt\n",
      "5\n",
      "[5.0]\n",
      "2\n",
      "[5.0, 2.0]\n",
      "*\n",
      "[10.0]\n",
      "11\n",
      "[10.0, 11.0]\n",
      "-\n",
      "[-1.0]\n",
      "q\n",
      "[-1.0, 'q']\n"
     ]
    }
   ],
   "source": [
    "# now make into class structure, first pass\n",
    "class Calculator:\n",
    "    def __init__(self):\n",
    "        \n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing\n",
    "        self.operations_list = {'+':oper.add,\n",
    "                           '-':oper.sub,\n",
    "                           '*':oper.mul,\n",
    "                           '/':oper.truediv,\n",
    "                           '^':oper.pow,\n",
    "                           '%':oper.mod,\n",
    "                          }\n",
    "        \n",
    "    def isoperation(self, value):\n",
    "        if value in self.operations_list.keys():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def isfloat(self, value):\n",
    "        try:\n",
    "            tmp = float(value)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "    def convert_user_input(self, value):\n",
    "        if self.isfloat(value):\n",
    "            return float(value)\n",
    "\n",
    "        elif(self.isoperation(value) or value=='q'):\n",
    "            return value # leave as is and interpret operation later\n",
    "        \n",
    "        # else this will return NoneType\n",
    "\n",
    "    def perform_operation(self, op,vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op](vals[0],vals[1])\n",
    "\n",
    "        return op\n",
    "\n",
    "\n",
    "print(\"Calculator prompt\")\n",
    "user_input = ''\n",
    "eval_queue = []\n",
    "calc = Calculator()\n",
    "while user_input != 'q': #arbitrary ending for RPN, will fix later\n",
    "    user_input = calc.convert_user_input(input(\"\"))\n",
    "    eval_queue.append(user_input)\n",
    "    \n",
    "    if calc.isoperation(eval_queue[-1]):\n",
    "            \n",
    "        result = eval_queue.pop()\n",
    "        \n",
    "        v2 = eval_queue.pop()\n",
    "        v1 = eval_queue.pop()\n",
    "        \n",
    "        result = calc.perform_operation(result,(v1,v2))\n",
    "        eval_queue.append(result)\n",
    "        \n",
    "    print(eval_queue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator\n",
      "Operations List: -, +, %, *, ^, /, \n",
      "3\n",
      "[3.0]\n",
      "3\n",
      "[3.0, 3.0]\n",
      "/\n",
      "[1.0]\n",
      "4\n",
      "[1.0, 4.0]\n",
      "^\n",
      "[1.0]\n",
      "7\n",
      "[1.0, 7.0]\n",
      "-\n",
      "[-6.0]\n",
      "+\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "pop from empty list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-6f9523af2a9f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m     \u001b[0;31m# otherwise use calculator model to get results\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m     \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddto_queue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muser_input\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     82\u001b[0m     \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_queue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-22-6f9523af2a9f>\u001b[0m in \u001b[0;36maddto_queue\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     30\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m             \u001b[0mv2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m             \u001b[0mv1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mperform_operation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: pop from empty list"
     ]
    }
   ],
   "source": [
    "# now lets make this more object oriented and really make the interface and model separate entities\n",
    "# Class stucture, second pass\n",
    "class Calculator:\n",
    "    def __init__(self):\n",
    "        \n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing\n",
    "        self.operations_list = {'+':oper.add,\n",
    "                                '-':oper.sub,\n",
    "                                '*':oper.mul,\n",
    "                                '/':oper.truediv,\n",
    "                                '^':oper.pow,\n",
    "                                '%':oper.mod,\n",
    "                               }\n",
    "        self.eval_queue = []\n",
    "       \n",
    "    #==Queue Operations========\n",
    "    def clear_queue(self):\n",
    "        self.eval_queue = []\n",
    "    \n",
    "    def print_queue(self):\n",
    "        print(self.eval_queue)\n",
    "        \n",
    "    def addto_queue(self,value):\n",
    "        self.eval_queue.append( self.convert_user_input(value) )\n",
    "    \n",
    "        # evaluate operation if it was entered\n",
    "        if self.isoperation(self.eval_queue[-1]):\n",
    "\n",
    "            result = self.eval_queue.pop()\n",
    "            v2 = self.eval_queue.pop()\n",
    "            v1 = self.eval_queue.pop()\n",
    "\n",
    "            result = calc.perform_operation(result,(v1,v2))\n",
    "            self.eval_queue.append(result)\n",
    "            \n",
    "    def print_operations(self):\n",
    "        # print supported operations\n",
    "        print('Operations List:', end=' ')\n",
    "        [print(x, end=', ') for x in self.operations_list.keys()]\n",
    "        print('')\n",
    "        \n",
    "    #==check type Operations========\n",
    "    def isoperation(self, value):\n",
    "        if value in self.operations_list.keys():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def isfloat(self, value):\n",
    "        try:\n",
    "            tmp = float(value)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "    #===evalaute operations============\n",
    "    def convert_user_input(self, value):\n",
    "        if self.isfloat(value):\n",
    "            return float(value)\n",
    "\n",
    "        elif self.isoperation(value) :\n",
    "            return value # leave as is and interpret operation later\n",
    "        \n",
    "        # else this will return NoneType\n",
    "\n",
    "    def perform_operation(self, op,vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op](vals[0],vals[1])\n",
    "        return op\n",
    "\n",
    "print(\"Calculator\")\n",
    "calc = Calculator()\n",
    "calc.print_operations()\n",
    "while True: #arbitrary ending for RPN, will fix later\n",
    "    user_input = input(\"\")\n",
    "    if user_input == 'q':\n",
    "        break\n",
    "        \n",
    "    # otherwise use calculator model to get results\n",
    "    calc.addto_queue(user_input)\n",
    "    calc.print_queue()\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End Example II-4\n",
    "____\n",
    "\n",
    "# Start Example II-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator\n",
      "Operations List: -, +, %, *, ^, /, \n",
      "45\n",
      "[45.0]\n",
      "5\n",
      "[45.0, 5.0]\n",
      "+\n",
      "[50.0]\n",
      "+\n",
      "Error:  Not enough values to perform operation\n",
      "[50.0]\n",
      "3\n",
      "[50.0, 3.0]\n",
      "/\n",
      "[16.666666666666668]\n",
      "eric\n",
      "[16.666666666666668, None]\n",
      "+\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'float' and 'NoneType'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-da4fdea6c24a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     89\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m         \u001b[0;31m# otherwise use calculator model to get results\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m         \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddto_queue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muser_input\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mCalculatorError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mErr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Error: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mErr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-25-da4fdea6c24a>\u001b[0m in \u001b[0;36maddto_queue\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     41\u001b[0m             \u001b[0mv1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mperform_operation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     44\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-25-da4fdea6c24a>\u001b[0m in \u001b[0;36mperform_operation\u001b[0;34m(self, op, vals)\u001b[0m\n\u001b[1;32m     76\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mperform_operation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misoperation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moperations_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'float' and 'NoneType'"
     ]
    }
   ],
   "source": [
    "# add in some exception handling\n",
    "# Class stucture, third pass\n",
    "class CalculatorError(ValueError):\n",
    "    '''raise this when the user causes a mistake from the calculator'''\n",
    "\n",
    "class Calculator:\n",
    "    def __init__(self):\n",
    "        \n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing\n",
    "        self.operations_list = {'+':oper.add,\n",
    "                                '-':oper.sub,\n",
    "                                '*':oper.mul,\n",
    "                                '/':oper.truediv,\n",
    "                                '^':oper.pow,\n",
    "                                '%':oper.mod,\n",
    "                               }\n",
    "        self.eval_queue = []\n",
    "       \n",
    "    #==Queue Operations========\n",
    "    def clear_queue(self):\n",
    "        self.eval_queue = []\n",
    "    \n",
    "    def print_queue(self):\n",
    "        print(self.eval_queue)\n",
    "        \n",
    "    def addto_queue(self,value):\n",
    "        self.eval_queue.append( self.convert_user_input(value) )\n",
    "    \n",
    "        \n",
    "        # evaluate operation if it was entered\n",
    "        if self.isoperation(self.eval_queue[-1]):\n",
    "\n",
    "            result = self.eval_queue.pop()\n",
    "            \n",
    "            if len(self.eval_queue)<2:\n",
    "                # not enough elements to perform an operation\n",
    "                raise CalculatorError('Not enough values to perform operation')\n",
    "                \n",
    "            v2 = self.eval_queue.pop()\n",
    "            v1 = self.eval_queue.pop()\n",
    "\n",
    "            result = calc.perform_operation(result,(v1,v2))\n",
    "            self.eval_queue.append(result)\n",
    "            \n",
    "    def print_operations(self):\n",
    "        # print supported operations\n",
    "        print('Operations List:', end=' ')\n",
    "        [print(x, end=', ') for x in self.operations_list.keys()]\n",
    "        print('')\n",
    "        \n",
    "    #==check type Operations========\n",
    "    def isoperation(self, value):\n",
    "        if value in self.operations_list.keys():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def isfloat(self, value):\n",
    "        try:\n",
    "            tmp = float(value)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "    #===evalaute operations============\n",
    "    def convert_user_input(self, value):\n",
    "        if self.isfloat(value):\n",
    "            return float(value)\n",
    "\n",
    "        elif self.isoperation(value) :\n",
    "            return value # leave as is and interpret operation later\n",
    "        \n",
    "        # else this will return NoneType\n",
    "\n",
    "    def perform_operation(self, op,vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op](vals[0],vals[1])\n",
    "        return op\n",
    "\n",
    "print(\"Calculator\")\n",
    "calc = Calculator()\n",
    "calc.print_operations()\n",
    "while True: #arbitrary ending for RPN, will fix later\n",
    "    user_input = input(\"\")\n",
    "    if user_input == 'q':\n",
    "        break\n",
    "        \n",
    "    try: \n",
    "        # otherwise use calculator model to get results\n",
    "        calc.addto_queue(user_input)\n",
    "    except CalculatorError as Err:\n",
    "        print(\"Error: \", Err)\n",
    "    calc.print_queue()\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator\n",
      "Operations List: -, +, %, *, ^, /, \n",
      "3\n",
      "Current Stack: [3.0]\n",
      "+\n",
      "Error:  Not enough values to perform operation\n",
      "Current Stack: [3.0]\n",
      "eric\n",
      "Error:  Invalid entry. Entry must be number or supported operator.\n",
      "Current Stack: [3.0]\n",
      "4\n",
      "Current Stack: [3.0, 4.0]\n",
      "_\n",
      "Error:  Invalid entry. Entry must be number or supported operator.\n",
      "Current Stack: [3.0, 4.0]\n",
      "-\n",
      "Current Stack: [-1.0]\n",
      "q\n"
     ]
    }
   ],
   "source": [
    "# add in some exception handling\n",
    "# Class stucture, fourth pass\n",
    "class CalculatorError(ValueError):\n",
    "    '''raise this when the user causes a mistake from the calculator'''\n",
    "\n",
    "class Calculator:\n",
    "    def __init__(self):\n",
    "        \n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing\n",
    "        self.operations_list = {'+':oper.add,\n",
    "                                '-':oper.sub,\n",
    "                                '*':oper.mul,\n",
    "                                '/':oper.truediv,\n",
    "                                '^':oper.pow,\n",
    "                                '%':oper.mod,\n",
    "                               }\n",
    "        self.eval_queue = []\n",
    "       \n",
    "    #==Queue Operations========\n",
    "    def clear_queue(self):\n",
    "        self.eval_queue = []\n",
    "    \n",
    "    def print_queue(self):\n",
    "        print(\"Current Stack:\", self.eval_queue)\n",
    "        \n",
    "    def addto_queue(self,value):\n",
    "        tmp = self.convert_user_input(value)\n",
    "        self.eval_queue.append( tmp )\n",
    "    \n",
    "        \n",
    "        # evaluate operation if it was entered\n",
    "        if self.isoperation(self.eval_queue[-1]):\n",
    "\n",
    "            result = self.eval_queue.pop()\n",
    "            \n",
    "            if len(self.eval_queue)<2:\n",
    "                # not enough elements to perform an operation\n",
    "                raise CalculatorError('Not enough values to perform operation')\n",
    "                \n",
    "            v2 = self.eval_queue.pop()\n",
    "            v1 = self.eval_queue.pop()\n",
    "\n",
    "            result = calc.perform_operation(result,(v1,v2))\n",
    "            self.eval_queue.append(result)\n",
    "            \n",
    "    def print_operations(self):\n",
    "        # print supported operations\n",
    "        print('Operations List:', end=' ')\n",
    "        [print(x, end=', ') for x in self.operations_list.keys()]\n",
    "        print('')\n",
    "        \n",
    "    #==check type Operations========\n",
    "    def isoperation(self, value):\n",
    "        if value in self.operations_list.keys():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def isfloat(self, value):\n",
    "        try:\n",
    "            tmp = float(value)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "    \n",
    "    def convert_user_input(self, value):\n",
    "        if self.isfloat(value):\n",
    "            return float(value)\n",
    "        elif self.isoperation(value) :\n",
    "            return value # leave as is and interpret operation later\n",
    "        else:\n",
    "            raise CalculatorError('Invalid entry. Entry must be number or supported operator.')\n",
    "\n",
    "    #===evalaute operations============\n",
    "    def perform_operation(self, op,vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op](vals[0],vals[1])\n",
    "        return op\n",
    "\n",
    "print(\"Calculator\")\n",
    "calc = Calculator()\n",
    "calc.print_operations()\n",
    "while True: #arbitrary ending for RPN, will fix later\n",
    "    user_input = input(\"\")\n",
    "    if user_input == 'q':\n",
    "        break\n",
    "\n",
    "    try: \n",
    "        # otherwise use calculator model to get results\n",
    "        calc.addto_queue(user_input)\n",
    "    except CalculatorError as Err:\n",
    "        print(\"Error: \", Err)\n",
    "    calc.print_queue()\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End Example II-6\n",
    "\n",
    "____\n",
    "\n",
    "# Start Example II-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator\n",
      "Operations List: -, abs, +, %, *, ^, tan, /, sine, cosine, \n",
      "56\n",
      "Current Stack: [56.0]\n",
      "tan\n",
      "Current Stack: [-0.6112736881917098]\n",
      "q\n"
     ]
    }
   ],
   "source": [
    "# add in custom user functions from JSON file\n",
    "# Class structure, fifth pass\n",
    "class CalculatorError(ValueError):\n",
    "    '''raise this when the user causes a mistake from the calculator'''\n",
    "\n",
    "class Operator:\n",
    "    def __init__(self, func, num_args=2):\n",
    "        self.func = func\n",
    "        self.num_args = num_args\n",
    "    \n",
    "    \n",
    "class CustomCalculator(Calculator):\n",
    "    def __init__(self):\n",
    "        # THIS OVERWRITES THE INIT FUNCTION OF INHERITED CLASS\n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing, include basic operations here\n",
    "        self.operations_list = {'+':Operator(oper.add),\n",
    "                                '-':Operator(oper.sub),\n",
    "                                '*':Operator(oper.mul),\n",
    "                                '/':Operator(oper.truediv),\n",
    "                                '^':Operator(oper.pow),\n",
    "                                '%':Operator(oper.mod),\n",
    "                                'abs':Operator(oper.abs,num_args=1),\n",
    "                               }\n",
    "        self.eval_queue = []\n",
    "        \n",
    "    def add_custom_operations(self,filename):\n",
    "        import json\n",
    "        with open(filename) as file:\n",
    "            data = json.loads(file.read()) # Grab file data\n",
    "\n",
    "        import math\n",
    "        for key,module in data.items():\n",
    "            if hasattr(math, module):\n",
    "                self.operations_list[key] = Operator(getattr(math, module), num_args = 1)\n",
    "                \n",
    "    def addto_queue(self,value):\n",
    "        tmp = self.convert_user_input(value)\n",
    "        self.eval_queue.append( tmp )\n",
    "    \n",
    "        \n",
    "        # evaluate operation if it was entered\n",
    "        if self.isoperation(self.eval_queue[-1]):\n",
    "\n",
    "            result = self.eval_queue.pop()\n",
    "            num_args = self.operations_list[result].num_args\n",
    "            \n",
    "            if len(self.eval_queue)<num_args:\n",
    "                # not enough elements to perform an operation\n",
    "                raise CalculatorError('Not enough values to perform operation')\n",
    "                \n",
    "            args = []\n",
    "            for i in range(num_args):\n",
    "                args.append(self.eval_queue.pop())\n",
    "\n",
    "            result = self.perform_operation(result,args)\n",
    "            self.eval_queue.append(result)\n",
    "            \n",
    "    def perform_operation(self, op, vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op].func(*vals) # pass list as arguments\n",
    "        return op\n",
    "\n",
    "print(\"Calculator\")\n",
    "calc = CustomCalculator()\n",
    "calc.add_custom_operations('operators.json') # new function\n",
    "calc.print_operations() # inherited function\n",
    "\n",
    "while True: \n",
    "    user_input = input(\"\")\n",
    "    if user_input == 'q':\n",
    "        break\n",
    "        \n",
    "    try: \n",
    "        # otherwise use calculator model to get results\n",
    "        calc.addto_queue(user_input) # overwritten function\n",
    "    except CalculatorError as Err:\n",
    "        print(\"Error: \", Err) \n",
    "        \n",
    "    calc.print_queue()\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator\n",
      "Operations List: -, abs, +, %, *, ^, tan, /, sine, cosine, \n",
      "45\n",
      "Current Stack: [45.0]\n",
      "3\n",
      "Current Stack: [45.0, 3.0]\n",
      "+\n",
      "Current Stack: [48.0]\n",
      "q\n"
     ]
    }
   ],
   "source": [
    "# adding decorators\n",
    "# Class structure, sixth pass\n",
    "class CalculatorError(ValueError):\n",
    "    '''raise this when the user causes a mistake from the calculator'''\n",
    "\n",
    "class Operator:\n",
    "    def __init__(self, func, num_args=2):\n",
    "        self.func = func\n",
    "        self.num_args = num_args\n",
    "    \n",
    "    \n",
    "class CustomCalculator(Calculator):\n",
    "    def __init__(self):\n",
    "        # THIS OVERWRITES THE INIT FUNCTION OF INHERITED CLASS\n",
    "        import operator as oper\n",
    "        # add dictionary of operations and function passing, include basic operations here\n",
    "        self.operations_list = {'+':Operator(oper.add),\n",
    "                                '-':Operator(oper.sub),\n",
    "                                '*':Operator(oper.mul),\n",
    "                                '/':Operator(oper.truediv),\n",
    "                                '^':Operator(oper.pow),\n",
    "                                '%':Operator(oper.mod),\n",
    "                                'abs':Operator(oper.abs,num_args=1),\n",
    "                               }\n",
    "        self.eval_queue = []\n",
    "        \n",
    "    def add_custom_operations(self,filename):\n",
    "        import json\n",
    "        with open(filename) as file:\n",
    "            data = json.loads(file.read()) # Grab file data\n",
    "\n",
    "        import math\n",
    "        for key,module in data.items():\n",
    "            if hasattr(math, module):\n",
    "                self.operations_list[key] = Operator(getattr(math, module), num_args = 1)\n",
    "                \n",
    "    def addto_queue(self,value):\n",
    "        tmp = self.convert_user_input(value)\n",
    "        self.eval_queue.append( tmp )\n",
    "    \n",
    "        \n",
    "        # evaluate operation if it was entered\n",
    "        if self.isoperation(self.eval_queue[-1]):\n",
    "\n",
    "            result = self.eval_queue.pop()\n",
    "            num_args = self.operations_list[result].num_args\n",
    "            \n",
    "            if len(self.eval_queue)<num_args:\n",
    "                # not enough elements to perform an operation\n",
    "                raise CalculatorError('Not enough values to perform operation')\n",
    "                \n",
    "            args = []\n",
    "            for i in range(num_args):\n",
    "                args.append(self.eval_queue.pop())\n",
    "\n",
    "            result = self.perform_operation(result,args)\n",
    "            self.eval_queue.append(result)\n",
    "            \n",
    "    def perform_operation(self, op, vals):\n",
    "        if self.isoperation(op):\n",
    "            return self.operations_list[op].func(*vals) # pass list as arguments\n",
    "        return op\n",
    "    \n",
    "    @staticmethod\n",
    "    def isfloat(value):\n",
    "        try:\n",
    "            tmp = float(value)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "print(\"Calculator\")\n",
    "calc = CustomCalculator()\n",
    "calc.add_custom_operations('operators.json') # new function\n",
    "calc.print_operations() # inherited function\n",
    "\n",
    "while True: \n",
    "    user_input = input(\"\")\n",
    "    if user_input == 'q':\n",
    "        break\n",
    "        \n",
    "    try: \n",
    "        # otherwise use calculator model to get results\n",
    "        calc.addto_queue(user_input) # overwritten function\n",
    "    except CalculatorError as Err:\n",
    "        print(\"Error: \", Err) \n",
    "        \n",
    "    calc.print_queue()\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# Possible Extensions\n",
    "- add a check for the number of operators for a given function, rather than manual entry from user/programmer\n",
    "- add exception handling for bad JSON or user entries that are not in the math module\n",
    "- add support for arbitrary modules and arbitrary functions from those modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# END WEEK 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [MLEnv]",
   "language": "python",
   "name": "Python [MLEnv]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}