DSFromScratch/Chap2/056-Chap2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object-Orientated Programming\n",
    "\n",
    "- Define *classes* that encapsulate data and the functions that operate on them. We use them to make code cleaner and simpler.\n",
    "- An example here of creating our own `Set` class.\n",
    "- What behavior should our class have? Given an instance of `Set`, we'll need to be able to `add` items to it, `remove` items from it and check whether it `contains` a certain value. We'll create all these as *member* functions, which means we'll access them with a . after a `Set` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Set:\n",
    "    # these are the member functions\n",
    "    # every one takes a first parameter \"self\" (another convention)\n",
    "    # that refers to the particular Set object being used\n",
    "    def __init__(self, values=None):\n",
    "        \"\"\"This is the constructor. It gets called when you create a new Set. You would use it like:\n",
    "        s1 = Set() # empty set\n",
    "        s2 = Set([1,2,2,3]) # initialize with values\"\"\"\n",
    "        \n",
    "        self.dict = {} # each instance of Set has its own dict property \n",
    "                       # which is what we'll use to track memberships\n",
    "        if values is not None:\n",
    "            for value in values:\n",
    "                self.add(value)\n",
    "                \n",
    "    # defining what gets printed out when you do print(s) where s is a Set object.\n",
    "    def __repr__(self):\n",
    "        \"\"\"this is the string representation of a Set object \n",
    "        if you type it at the Python prompt or pass it to str()\"\"\"\n",
    "        return \"Set: \" + str(self.dict.keys())\n",
    "    \n",
    "    # we'll represent membership by being a key in self.dict with value True\n",
    "    def add(self, value):\n",
    "        self.dict[value] = True\n",
    "        \n",
    "    # value is in the Set if it's a key in the dictionary\n",
    "    def contains(self, value):\n",
    "        return value in self.dict\n",
    "    \n",
    "    def remove(self, value):\n",
    "        del self.dict[value]\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which we could then use like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Set: dict_keys([1, 2, 4])\n"
     ]
    }
   ],
   "source": [
    "s = Set([1,2,2,3])\n",
    "s.add(4)\n",
    "print (s.contains(4)) # True\n",
    "s.remove(3)\n",
    "print (s.contains(3)) # False\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set: dict_keys(['very', 'Some', 'words', 'interesting'])\n"
     ]
    }
   ],
   "source": [
    "s = Set([\"Some\",\"very\",\"very\",\"interesting\",\"words\"])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functional Tools\n",
    "\n",
    "Sometimes we may want to patially apply functions to create new functions.         \n",
    "Imagine we have a function of two variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def exp(base, power):\n",
    "    return base ** power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to use this to create a function of one variable `two_to_the` whose input is a `power` and whose output is the result of `exp(2, power)`.\n",
    "\n",
    "We could do this with def, but can be unwieldy(not sure I understand):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def two_to_the(power):\n",
    "    return exp(2, power) # using exp function above\n",
    "\n",
    "print(two_to_the(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A different approach is to use functools.partial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "# This is like saying pass argument of 2 to exp. When you call two_to_the it takes the 3 and gives it exp.\n",
    "# It is also like saying...we will partially fill in the exp function with a 2. You give the other argument when say \n",
    "# two_to_the(3).\n",
    "two_to_the = partial(exp,2)\n",
    "\n",
    "\n",
    "print (two_to_the(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use a `partial` to fill in later aruguments if you specify their names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# This time we say that we are filling in the power argument of exp.\n",
    "square_of = partial(exp, power = 2)\n",
    "\n",
    "print (square_of(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also occasionally use `map`,`reduce`,`filter`, which provide functional alternatives to list comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    return 2 * x\n",
    "\n",
    "xs = [1,2,3,4]\n",
    "twice_xs = [double(x) for x in xs]   # [2, 4, 6, 8]\n",
    "twice_xs = map(double, xs)           # [2, 4, 6, 8]\n",
    "\n",
    "# combining partial with map\n",
    "list_doubler = partial(map, double)  # *function* that double a list\n",
    "twice_xs = list_doubler(xs)          # again [2, 4, 6, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `map` with multiple-argument functions if you provide multiple lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 10]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(x, y): return x * y\n",
    "\n",
    "products = map(multiply, [1,2], [4,5]) # [1 * 4, 2 * 5] = [4, 10]\n",
    "\n",
    "# In python 3 products is still an iterable, so you need to use list comprehension\n",
    "[x for x in products]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, `filter` does the work of a list-comprehension `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_even(x):\n",
    "    \"\"\"True if x is even, False if x is odd\"\"\"\n",
    "    return x % 2 == 0\n",
    "\n",
    "xs = [1,2,3,4]\n",
    "x_evens = [x for x in xs if is_even(x)]  # [2, 4]\n",
    "x_evens = filter(is_even, xs)            # same as above\n",
    "\n",
    "list_evener = partial(filter, is_even)   # *function* that filters a list\n",
    "x_evens = list_evener(xs)                # again [2, 4]\n",
    "[x for x in x_evens]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`reduce` combines the first two elements of a list, then that result with the third, that result with the fourth, and so on, producing a single result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    " # reduce not built into python 3. Documentation says a for loop is nearly always clearer\n",
    "from functools import reduce \n",
    "\n",
    "xs = [1,2,3,4]\n",
    "x_product = reduce(multiply, xs) # = 1 * 2 * 3 * 4 = 24\n",
    "\n",
    "list_product = partial(reduce, multiply) # *function* that reduces a list\n",
    "print(list_product(xs)) # just need to feed in the list to let reduce() and multiply() get to work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## zip and Argument Unpacking\n",
    "\n",
    "Often we need to `zip` two or more lists together. `zip` transforms multiple lists into a single list of tuples of corresponding elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list1 = ['a','b','c']\n",
    "list2  =[1, 2, 3]\n",
    "pairs = zip(list1, list2)\n",
    "#[x for x in pairs] # using this exhausts the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`zip` stops as soon as the first list ends.\n",
    "\n",
    "You can also \"unzip\" a list with this trick:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 'c')\n"
     ]
    }
   ],
   "source": [
    "# The asterisk performs argument unpacking\n",
    "letters, numbers = zip(*pairs)\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'b', 'c'), (1, 2, 3)]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(('a',1),('b',2),('c',3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use argument unpacking with any function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(a, b): return a + b\n",
    "\n",
    "add(1,2) # returns 3\n",
    "add([1,2]) # TypeError!\n",
    "add(*[1,2]) # returns 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## args and kwargs\n",
    "\n",
    "We need a way to specify a function that takes arbitrary arguments. We can do this with argument unpacking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unnamed args: (1, 2)\n",
      "keyword args: {'key': 'word', 'key2': 'word2'}\n"
     ]
    }
   ],
   "source": [
    "def magic(*args, **kwargs):\n",
    "    print (\"unnamed args:\", args)\n",
    "    print (\"keyword args:\", kwargs)\n",
    "\n",
    "magic(1,2, key  =\"word\", key2=\"word2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`args` is a tuple of its unnamed arguments and `kwargs` is a `dict` of its named arguments.   \n",
    "It works the other way too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def other_way_magic(x,y,z):\n",
    "    return x + y + z\n",
    "\n",
    "\n",
    "z_dict = { \"z\" : 3 }\n",
    "\n",
    "# * specifies the unnamed arguments 1, 2 and ** provides a named argument 3.\n",
    "# These are all added together in other_way_magic\n",
    "print (other_way_magic(*x_y_list, **z_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do all sorts of tricks with this; we will only use it to produce higher-order functions whose inputs can accept arbitrary arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'f2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-103-6ee431029c31>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdoubler_correct\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'f2' is not defined"
     ]
    }
   ],
   "source": [
    "def doubler_correct(f):\n",
    "    \"\"\"works no matter what kind of inputs f expects\"\"\"\n",
    "    def g(*args, **kwargs):\n",
    "        \"\"\"whatever arguments g is supplied, pass them through to f\"\"\"\n",
    "        return 2 * f(*args, **kwargs)\n",
    "    return g\n",
    "\n",
    "g = doubler_correct(f2)\n",
    "print(g(1, 2))"
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}