03-01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 4 - Thinking about Functions\n",
    "\n",
    "## Week 3 Monday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "Adapted from Think Python by Allen B Downey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of the nature of turtle graphics, I cannot make today's lecture a slideshow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup so Turtle Graphics work with Jupyter\n",
    "\n",
    "From the prompt type the following two commands.\n",
    "\n",
    "First install ipyturtle\n",
    "~~~\n",
    "pip install ipyturtle\n",
    "~~~\n",
    "\n",
    "Second, enable ipyturtle to work in jupyter notebook\n",
    "~~~\n",
    "jupyter nbextension enable --py --sys-prefix ipyturtle\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started with Turtle Graphics:\n",
    "\n",
    "within the module `ipyturtle`, there is a function called `Turtle()` which will create an instance of a turtle. You can name this turtle anything, but traditionally it is named `t`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from ipyturtle import Turtle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "bob = Turtle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "731b0ab6bd964405b18b955488698773",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Turtle()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moving the Turtle\n",
    "\n",
    "### Move and draw\n",
    "\n",
    "- `forward()`\n",
    "- `backward()`\n",
    "- `right()`\n",
    "- `left()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.forward(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.forward(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.right(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.forward(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# will draw a square:\n",
    "bob.forward(100)\n",
    "bob.left(90)\n",
    "\n",
    "bob.forward(100)\n",
    "bob.left(90)\n",
    "\n",
    "bob.forward(100)\n",
    "bob.left(90)\n",
    "\n",
    "bob.forward(100)\n",
    "bob.left(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A `for` loop\n",
    "\n",
    "A for loop will repeat the associated code a set number of times.\n",
    "\n",
    "The simplest is to use a `range()` object which creates an iterable that begins at 0 and ends at 3 (a total length of 4)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# will draw a square:\n",
    "for i in range(4):\n",
    "    bob.forward(100)\n",
    "    bob.left(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Encapuslating and Generalizing code with functions\n",
    "\n",
    "When writing functions, it is important to think about encapsulating and generalizing the code.\n",
    "\n",
    "# Encapsulation\n",
    "\n",
    "At the most basic level, a function encapsulates a few lines of code. This associates a name with statements and allows us to reuse the code.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square():\n",
    "    for i in range(4):\n",
    "        bob.forward(100)\n",
    "        bob.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "square()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Side note: Indentation defines code blocks\n",
    "\n",
    "Python does not use curly braces `{}` to define code blocks.\n",
    "IPython is smart enough to automatically indent lines after you use a colon `:` which indicates that the following lines are part of a code block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n",
      "8\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "# we will learn if statements later, but here's an example\n",
    "x = 8\n",
    "if(x > 5):\n",
    "    print('x is greater than 5')   # the two indented lines only run \n",
    "    print(x)                       # when the if statement is true\n",
    "print('hello')    # this line is not indented and will run regardless of if statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "if(x > 5):\n",
    "    print('x is greater than 5')   # the two indented lines only run \n",
    "    print(x)                       # when the if statement is true\n",
    "print('hello')    # this line is not indented and will run regardless of if statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "if(x > 5):\n",
    "    print('x is greater than 5')\n",
    "print(x)\n",
    "print('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "next line\n",
      "1\n",
      "next line\n",
      "2\n",
      "next line\n",
      "3\n",
      "next line\n",
      "4\n",
      "next line\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "for x in range(5):\n",
    "    print(x)\n",
    "    print(\"next line\")\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Side note: The range object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want just a sequence of numbers, you can use a `range()` object.\n",
    "\n",
    "`range(10)` is similar to calling 0:9 in R. It creates a range of indexes that is 10 items long, but begins with index 0.\n",
    "\n",
    "the general format is \n",
    "\n",
    "`range( start , end , step size)`\n",
    "\n",
    "by default, the range will begin at the start value, increment by step size, and go up to but not include the end value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i, end = ' ') \n",
    "    # the end argument tells python to use a space rather than a new line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(5, 10)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5,10)  # creates a range from 5 up to but not including 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5,10))  # if you want to see the actual values, throw in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 20, 2))  # range from 0 to 20 by 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 21, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'float' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-26-7c865feae284>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m20.1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#does not accept floats as arguments\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "list(range(0, 20.1, 2))  #does not accept floats as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10,5,-1)) # need to specify a negative step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10,5)) # otherwise you get no values in your list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generalization\n",
    "\n",
    "Generalization adds variables to functions so that the same function can be slightly altered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(t):\n",
    "    for i in range(4):\n",
    "        t.forward(100)\n",
    "        t.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a new turtle called carl\n",
    "carl = Turtle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# carl's color is blue\n",
    "carl.pencolor(\"blue\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "12c2b161245b4cf299aeeb98d57e02e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Turtle()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# switch to carl\n",
    "carl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(carl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "731b0ab6bd964405b18b955488698773",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Turtle()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# switch back to bob\n",
    "bob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# further generalize by adding an argument for length\n",
    "def square(t, length):\n",
    "    for i in range(4):\n",
    "        t.forward(length)\n",
    "        t.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(bob, 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(bob, 120)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## more generalization of the function:\n",
    "\n",
    "We can make a polygon function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can we draw a pentagon?\n",
    "angle = 360 / 5\n",
    "for i in range(5):\n",
    "    bob.forward(50)\n",
    "    bob.left(angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can we draw a hexagon?\n",
    "angle = 360 / 6\n",
    "for i in range(6):\n",
    "    bob.forward(50)\n",
    "    bob.left(angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# after creating the code for a pentagon and hexagon, we can generalize to a\n",
    "# n sided polygon\n",
    "def polygon(t, n, length):\n",
    "    angle = 360 / n\n",
    "    for i in range(n):\n",
    "        t.forward(length)\n",
    "        t.left(angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "polygon(bob, 3, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "polygon(bob, 5, 70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "polygon(bob, 7, 70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "def circle(t, r):\n",
    "    circumference = 2 * math.pi * r\n",
    "    n = 50 # not a true circle, 50 sided polygon\n",
    "    length = circumference / n\n",
    "    polygon(t, n, length) # no need to rewrite the code, just call the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "circle(bob, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle(bob, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle(bob, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interface Design\n",
    "\n",
    "For a function, the iterface is how the user interacts with a function.\n",
    "\n",
    "Ideally, the function is flexible enough to let the user do what they need to do, but not so complex to weigh the user down with unnecessary info.\n",
    "\n",
    "For example, with our circle function, we have arbitrarily chosen to draw a 50 sided polygon. This number is probably not high enough for very big circles, but also too big for very small circles.\n",
    "\n",
    "One solution is to choose a value of n that depends on the size of the circle. If the circle has a large circumference, we need a larger n. If the circumference is smaller, we can choose a smaller n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circle(t, r):\n",
    "    circumference = 2 * math.pi * r\n",
    "    n = int(circumference / 3) + 1\n",
    "    length = circumference / n\n",
    "    polygon(t, n, length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our definition, we set n to be an integer about 1/3rd of the circumference. This means that the length value will be approximately equal to 3.\n",
    "\n",
    "The user does not need to specify n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle(bob, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle(bob, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a function for an arc\n",
    "\n",
    "How can we create a function to draw an arc?\n",
    "\n",
    "The arc would need two arguments (in addition to specifying the turtle):\n",
    "- the radius of the arc\n",
    "- the angle of the arc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's draw an arc with radius 50 and 60 degrees 1/6 of circle\n",
    "\n",
    "r = 50\n",
    "angle = 60\n",
    "circumference = math.pi * 2 * r\n",
    "arc_length = circumference * 60/360\n",
    "n = 30 # number of steps\n",
    "step_size = arc_length / n\n",
    "step_angle = angle / n\n",
    "for i in range(n):\n",
    "    bob.forward(step_size)\n",
    "    bob.left(step_angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's draw an arc with radius 100 and 30 degrees\n",
    "\n",
    "r = 100\n",
    "angle = 30\n",
    "circumference = math.pi * 2 * r\n",
    "arc_length = circumference * 30/360\n",
    "n = 30 # number of steps\n",
    "step_size = arc_length / n\n",
    "step_angle = angle / n\n",
    "for i in range(n):\n",
    "    bob.forward(step_size)\n",
    "    bob.left(step_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's think about how to generalize this to a function\n",
    "\n",
    "Like earlier, we'll change the number of steps to depend on the total length being drawn.\n",
    "\n",
    "I'll put everything into a single function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arc(t, r, angle):\n",
    "    circumference = math.pi * 2 * r\n",
    "    arc_length = circumference * angle/360\n",
    "    n = int(arc_length / 3) + 1\n",
    "    step_size = arc_length / n\n",
    "    step_angle = angle / n\n",
    "    for i in range(n):\n",
    "        t.forward(step_size)\n",
    "        t.left(step_angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "arc(bob, 50, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "arc(bob, 30, 270)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Refactoring\n",
    "\n",
    "We have defined the funciton arc, however we are reusing elements that can be made into functions themselves.\n",
    "\n",
    "The last part with the for loop looks very much like the polygon function, but doesn't necessarily draw a closed polygon.\n",
    "\n",
    "Instead, we can create a function called `polyline()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def polyline(t, n, length, angle):\n",
    "    for i in range(n):\n",
    "        t.forward(length)\n",
    "        t.left(angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "polyline(bob, 3, 30, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now rewrite the polygon function to use polyline. The angle will be 360/n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def polygon(t, n, length):\n",
    "    angle = 360 / n\n",
    "    polyline(t, n, length, angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "polygon(bob, 4, 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "polygon(bob, 6, 40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also redefine the arc function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arc(t, r, angle):\n",
    "    arc_length = 2 * math.pi * r * angle / 360\n",
    "    n = int(arc_length / 3) + 1\n",
    "    step_length = arc_length / n\n",
    "    step_angle = angle / n\n",
    "    polyline(t, n, step_length, step_angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "arc(bob, 50, 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "arc(bob, 100, 90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we redefine circle as a function that uses `arc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circle(t, r):\n",
    "    arc(t, r, 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob.reset()\n",
    "circle(bob, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This process is known as **refactoring**.\n",
    "\n",
    "It is useful to write functions in a way that uses other functions rather than redefining common elements."
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}