03-03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 6 - More Lists, Strategies for writing functions\n",
    "\n",
    "## Week 3 Friday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "Adapted from Chapter 6 of Think Python by Allen B Downey\n",
    "\n",
    "List content adapted from \"Whirlwind Tour of Python\" by Jake VanderPlas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More on Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# List Methods\n",
    "\n",
    "- `list.copy()`\n",
    "    - Return a shallow copy of the list. Equivalent to a[:]\n",
    "- `list.append(x)`\n",
    "    - Add an item to the end of the list. Equivalent to a[len(a):] = [x]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me']\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.append(\"me\")   # unlike R, you don't have to \"capture\" the result of the function. \n",
    "# the list itself is modified. You can only append one item.\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', 1.8]\n"
     ]
    }
   ],
   "source": [
    "fam = fam + [1.8]  # you can also append to a list with the addition `+` operator\n",
    "# note that this output needs to be 'captured' and assigned back to fam\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', 1.8]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "fam.append(['miles', 1.78, 'joe', 1.8]) # append will add the entire object as one list entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89,\n",
       " 'me',\n",
       " 1.8,\n",
       " ['miles', 1.78, 'joe', 1.8]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89,\n",
       " 'miles',\n",
       " 1.78,\n",
       " 'joe',\n",
       " 1.8]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam + ['miles', 1.78, 'joe', 1.8] # plus operator concatenates the lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.insert(i, x)`\n",
    "    - Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).\n",
    "\n",
    "- `list.extend(iterable)`\n",
    "    - Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'joe', 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, \"joe\") # inserts joe at the location of the 4th comma between 1.68 and mom\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, ['joe', 2.0], 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, [\"joe\", 2.0])  # trying to insert multiple items by using a list inserts a list\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "insert() takes exactly 2 arguments (3 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-cb6806003168>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mfam\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"liz\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1.73\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"emma\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1.68\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"mom\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1.71\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"dad\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1.89\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mfam\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"joe\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2.0\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# like append, you can only insert one item\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;31m# trying to insert multiple items causes and error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfam\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: insert() takes exactly 2 arguments (3 given)"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, \"joe\", 2.0)  # like append, you can only insert one item\n",
    "# trying to insert multiple items causes and error\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'joe', 2.0]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.extend([\"joe\", 2.0]) # lets you add multiple items, but at the end\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'joe', 2.0, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam[4:4] = [\"joe\", 2.0] # Use slice and assignment to insert multiple items in a specific position\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.remove(x)`\n",
    "    - Remove the first item from the list whose value is x. It is an error if there is no such item.\n",
    "\n",
    "- `list.pop([i])`\n",
    "    - Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.\n",
    "\n",
    "- `list.clear()`\n",
    "    - Remove all items from the list. Equivalent to del a[:].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.remove(\"liz\")\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.89\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad']\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "j = fam.pop()  # if you don't specify an index, it pops the last item in the list\n",
    "# default behavior of pop() without any arguments is like a stack. last in first out\n",
    "print(j)\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "liz\n",
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "j = fam.pop(0)  # you can also specify an index.\n",
    "# Using index 0 makes pop behave like a queue. first in first out\n",
    "print(j)\n",
    "print(fam)\n",
    "\n",
    "fam.clear()\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "- `list.index(x)`\n",
    "    - Return zero-based index in the list of the first item whose value is x. Raises a ValueError if there is no such item.\n",
    "- `list.count(x)`\n",
    "    - Return the number of times x appears in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.index(\"emma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "3 is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-63a35f148e9b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfam\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: 3 is not in list"
     ]
    }
   ],
   "source": [
    "fam.index(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "letters = [\"a\", \"b\", \"c\", \"a\", \"a\"]\n",
    "print(letters.count(\"a\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "fam2 = [[\"liz\", 1.73],\n",
    "[\"emma\", 1.68],\n",
    "[\"mom\", 1.71],\n",
    "[\"dad\", 1.89]]\n",
    "print(fam2.count(\"emma\"))  # the string by itself does not exist\n",
    "print(fam2.count([\"emma\", 1.68]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.sort(key=None, reverse=False)`\n",
    "    - Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).\n",
    "\n",
    "- `list.reverse()`\n",
    "    - Reverse the elements of the list in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "fam.reverse()  # no output to 'capture', the list is changed in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.89, 'dad', 1.71, 'mom', 1.68, 'emma', 1.73, 'liz']\n"
     ]
    }
   ],
   "source": [
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-b0f2370e264b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfam\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# can't sort floats and string\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'float'"
     ]
    }
   ],
   "source": [
    "fam.sort()  # can't sort floats and string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "some_digits = [4, 2, 7, 9, 2, 5.1, 3]\n",
    "some_digits.sort()  # the list is sorted in place. no need to resave the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 3, 4, 5.1, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "print(some_digits)  # preserves numeric data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(some_digits[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 7, 5.1, 4, 3, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "some_digits.sort(reverse = True)\n",
    "print(some_digits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 3, 4, 5.1, 7, 9]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_digits = [4,2,7,9,2,5.1,3]\n",
    "sorted(some_digits)  # sorted will return a sorted copy of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 7, 9, 2, 5.1, 3]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_digits  # the list is unaffected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Coding Strategy: Incremental Development\n",
    "\n",
    "Chapter 6 - Think Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Develop your code incrementally.\n",
    "\n",
    "Don't try to get everything working all at once.\n",
    "\n",
    "Add one or two lines of code at a time. Check to make sure it works with different test cases. Move to add another piece."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Example: Write a distance function\n",
    "\n",
    "$$distance = \\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# start with a basic function definition:\n",
    "def distance(x1, y1, x2, y2):\n",
    "    return 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance(1, 2, 4, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The function doesn't compute the distance, but it runs without errors.\n",
    "\n",
    "We add a few lines to computer some intermediate values. Using intermediate values are always helpful. It eases the mental burden of having to parse values, especially if you give your intermediate values good variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def distance(x1, y1, x2, y2):\n",
    "    dx = x2 - x1\n",
    "    dy = y2 - y1\n",
    "    print('dx is', dx)\n",
    "    print('dy is', dy)\n",
    "    return 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx is 3\n",
      "dy is 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we test the function. We know that dx should be 3 and dy should be 4\n",
    "distance(1, 2, 4, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results match our expectation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def distance(x1, y1, x2, y2):\n",
    "    dx = x2 - x1\n",
    "    dy = y2 - y1\n",
    "    dsquared = dx**2 + dy**2\n",
    "    print('dsquared is:', dsquared)\n",
    "    return 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dsquared is: 25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance(1, 2, 4, 6) # check to see if we get our expected value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(x1, y1, x2, y2):\n",
    "    dx = x2 - x1\n",
    "    dy = y2 - y1\n",
    "    dsquared = dx**2 + dy**2\n",
    "    result = math.sqrt(dsquared)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance(1, 2, 4, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The `print` statements we wrote are useful for debugging, but once you get the function working, you should remove them. Code like that is called scaffolding because it is helpful for building the program but is not part of the final product.\n",
    "\n",
    "1. Start with a working program and make small incremental changes. At any point, if there is an error, you should have a good idea where it is.\n",
    "2. Use variables to hold intermediate values so you can display and check them.\n",
    "3. Once the program is working, you might want to remove some of the scaffolding or consolidate multiple statements into compound expressions, but only if it does not make the program difficult to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# more concise, but harder to read\n",
    "def distance(x1, y1, x2, y2):\n",
    "    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance(1, 2, 4, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Coding Strategy: Composition\n",
    "\n",
    "Write a function that takes two points, the center of the circle and a point on the perimeter, and computes the area of the circle.\n",
    "\n",
    "Assume that the center point is stored in the variables `xc` and `yc`, and the perimeter point is in `xp` and `yp`.\n",
    "\n",
    "We can break this into a couple steps:\n",
    "\n",
    "Find the radius using our distance function.\n",
    "\n",
    "`radius = distance(xc, yc, xp, yp)`\n",
    "\n",
    "Find the area of a circle given the radius, which we will need to define.\n",
    "\n",
    "`result = area(radius)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def area(radius):\n",
    "    result = math.pi * radius ** 2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def circle_area(xc, yc, xp, yp):\n",
    "    radius = distance(xc, yc, xp, yp)\n",
    "    result = area(radius)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# we can choose to make our code more concise if we wish. But this is not necessary.\n",
    "def circle_area(xc, yc, xp, yp):\n",
    "    return area(distance(xc, yc, xp, yp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78.53981633974483"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle_area(0, 0, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.566370614359172"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle_area(0,0, math.sqrt(2), math.sqrt(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Useful idea: Boolean Functions\n",
    "\n",
    "Boolean functions are function that return either `True` or `False`\n",
    "\n",
    "Convention says that these functions should be written as a yes/no question like `is_divisible(x,y)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "def is_divisible(x, y):\n",
    "    if x % y == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_divisible(6, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_divisible(6, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Because the result of the `==` operator is boolean, we can simplify by simply returning the expression directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# more concise and readable\n",
    "def is_divisible(x, y):\n",
    "    return x % y == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can use the result in conditional statements like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is divisible by y\n"
     ]
    }
   ],
   "source": [
    "x = 6\n",
    "y = 3\n",
    "if is_divisible(x, y):\n",
    "    print('x is divisible by y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Don't write a statement that is equivalent to `if True == True:`\n",
    "\n",
    "That extra comparison is unnecessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is divisible by y\n"
     ]
    }
   ],
   "source": [
    "# if is_divisible(x, y): is much preferred\n",
    "if is_divisible(x, y) == True:\n",
    "    print('x is divisible by y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Revisit the Factorial function\n",
    "\n",
    "Let's write the factorial function incrementally:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we simply define the function. Right now it does nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's add the base case. If the argument is 0, we return 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "factorial(4) # returns nothing because we haven't written the code yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If we have anything other than 0, we make a recursive call.\n",
    "\n",
    "We keep in mind that 4! = 4 * 3!, and more generally n! = n * (n-1)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        recurse = factorial(n - 1)\n",
    "        result = n * recurse\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Debugging your recursive code\n",
    "\n",
    "When you are trying to write a recursive function, you can quickly run into errors and will want some strategies to debug.\n",
    "\n",
    "One simple method is to add print statements declaring what is being done.\n",
    "\n",
    "In the following function, we add a print statement preceeded by spaces to indicate the steps.\n",
    "\n",
    "We put a print statement at the beginning of the function. We also put a print statement before the `return` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    spaces = \" \" * (4 * n)\n",
    "    print(spaces, 'factorial', n) # print statement for function call\n",
    "    if n == 0:\n",
    "        print(spaces, 'returning 1') # print statement for return values\n",
    "        return 1\n",
    "    else:\n",
    "        recurse = factorial(n - 1)\n",
    "        result = n * recurse\n",
    "        print(spaces, 'returning', result) # print statement for return values\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 factorial 4\n",
      "             factorial 3\n",
      "         factorial 2\n",
      "     factorial 1\n",
      " factorial 0\n",
      " returning 1\n",
      "     returning 1\n",
      "         returning 2\n",
      "             returning 6\n",
      "                 returning 24\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Checking for input types\n",
    "\n",
    "It is often important to check input types of a function so that executing the function does not cause errors.\n",
    "\n",
    "The function `isinstance(x, type)` can be used to check if object x is of a particular type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(5, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(5.3, float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(False, bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if not isinstance(n, int):\n",
    "        print('Factorial is only defined for integers.')\n",
    "        return None\n",
    "    elif n < 0:\n",
    "        print('Factorial is not defined for negative values.')\n",
    "        return None\n",
    "    elif n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        recurse = factorial(n - 1)\n",
    "        result = n * recurse\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial is only defined for integers.\n"
     ]
    }
   ],
   "source": [
    "factorial(1.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial is not defined for negative values.\n"
     ]
    }
   ],
   "source": [
    "factorial(-3)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}