07 Practice with functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_cell": true
   },
   "source": [
    "<span class='note'><i>Make me look good.</i> Click on the cell below and press <kbd>Ctrl</kbd>+<kbd>Enter</kbd>.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide_cell": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Lora:400,700,400i,700i' rel='stylesheet'>\n",
       "<link href='https://fonts.googleapis.com/css?family=Lato:300,400,700,300i,400i,700i' rel='stylesheet'>\n",
       "<link href='https://fonts.googleapis.com/css?family=Inconsolata:400' rel='stylesheet'>\n",
       "<link rel=\"stylesheet\" href=\"http://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css\">\n",
       "<style>\n",
       "    h1, h2, h3, h4, h5 {\n",
       "        font-family: 'Lato', sans-serif;\n",
       "    }\n",
       "    h5 {\n",
       "        font-style: normal;\n",
       "    }\n",
       "    kbd {\n",
       "        font-family: Lato, serif;\n",
       "    }\n",
       "    hr {\n",
       "      border-width: 2px;\n",
       "      border-color: #a9a9a9;\n",
       "    }\n",
       "    .cite {\n",
       "        font-size: 85%;\n",
       "        text-align: right;\n",
       "        margin-top: 10px;\n",
       "    }\n",
       "    .note {\n",
       "        font-family: Lora, serif;\n",
       "        font-size: 10pt;\n",
       "        font-weight: 400;\n",
       "        margin-top: 0;\n",
       "        margin-bottom: 0;\n",
       "    }\n",
       "    h5.prehead {\n",
       "        font-family: Lato, serif;\n",
       "        font-style: normal;\n",
       "        font-size: 13pt;\n",
       "        font-weight: 300;\n",
       "        margin-bottom: 15px;\n",
       "        margin-top: 30px;\n",
       "    }\n",
       "    h5.lesson {\n",
       "        font-family: Lato, serif;\n",
       "        font-weight: 400;\n",
       "        font-size: 15pt;\n",
       "        font-style: normal;\n",
       "        margin-top: 0px;\n",
       "        margin-bottom: 5px;\n",
       "    }\n",
       "    h1.lesson_title {\n",
       "        font-family: Lato, serif;\n",
       "        font-weight: 300;\n",
       "        font-size: 32pt;\n",
       "        line-height: 110%;\n",
       "        color:#CD2305;\n",
       "        margin-top: 0px;\n",
       "        margin-bottom: 15px;\n",
       "    }\n",
       "    div.cell{\n",
       "        max-width: 960px;\n",
       "        margin-left: auto;\n",
       "        margin-right: auto;\n",
       "    }\n",
       "    div.text_cell_render {\n",
       "        font-family: Lora, serif;\n",
       "        line-height: 160%;\n",
       "        font-size: 11pt;\n",
       "    }\n",
       "    .rendered_html pre, .rendered_html code  {\n",
       "        font-family: Inconsolata, monospace !important;\n",
       "        font-size: 11pt;\n",
       "    }\n",
       "    div.CodeMirror, div.output_area pre, div.prompt {\n",
       "        font-family: Inconsolata, monospace !important;\n",
       "        font-size: 110%;\n",
       "    }\n",
       "    .rendered_html ul li {\n",
       "        margin-top: 0.75em;\n",
       "        margin-bottom: 0.75em;\n",
       "    }\n",
       "    .rendered_html ul li ul li {\n",
       "        margin-top: 0.5em;\n",
       "        margin-bottom: 0.5em;\n",
       "    }\n",
       "    .rred {\n",
       "        color: #a00000;\n",
       "    }\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": \"0.75em 0\"}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "HTML(open('css/custom.css', 'r').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_cell": true
   },
   "source": [
    "<h5 class='prehead'>SM286D &middot; Introduction to Applied Mathematics with Python &middot; Spring 2020 &middot; Uhan</h5>\n",
    "\n",
    "<h5 class='lesson'>Lesson 7.</h5>\n",
    "\n",
    "<h1 class='lesson_title'>Practice with functions</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classwork"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 1.__ __Refactoring__ is the process of restructuring computer code without changing its external behavior. Typically, we refactor our code to make it easier to read, less complex, and more flexible.\n",
    "\n",
    "Take a look at the code below. Note that `midshipmen` is a list of dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Foraker\n",
      "Company: 3\n",
      "Service assignment preference: NFO\n",
      "\n",
      "Name: Uhan\n",
      "Company: 17\n",
      "Service assignment preference: Marine Ground\n",
      "\n",
      "Name: Traves\n",
      "Company: 11\n",
      "Service assignment preference: Nuke SWO\n",
      "\n",
      "Name: Phillips\n",
      "Company: 5\n",
      "Service assignment preference: SWO\n",
      "\n",
      "Name: Svirsko\n",
      "Company: 25\n",
      "Service assignment preference: Navy Pilot\n",
      "\n"
     ]
    }
   ],
   "source": [
    "midshipmen = [\n",
    "    {'name': 'foraker', 'company': 3, 'preference': 'NFO'},\n",
    "    {'name': 'uhan', 'company': 17, 'preference': 'Marine Ground'},\n",
    "    {'name': 'traves', 'company': 11, 'preference': 'Nuke SWO'},\n",
    "    {'name': 'phillips', 'company': 5, 'preference': 'SWO'},\n",
    "    {'name': 'svirsko', 'company': 25, 'preference': 'Navy Pilot'}\n",
    "]\n",
    "\n",
    "mid = midshipmen[0]\n",
    "print(f\"Name: {mid['name'].title()}\")\n",
    "print(f\"Company: {mid['company']}\")\n",
    "print(f\"Service assignment preference: {mid['preference']}\\n\")\n",
    "      \n",
    "mid = midshipmen[1]\n",
    "print(f\"Name: {mid['name'].title()}\")\n",
    "print(f\"Company: {mid['company']}\")\n",
    "print(f\"Service assignment preference: {mid['preference']}\\n\")\n",
    "      \n",
    "mid = midshipmen[2]\n",
    "print(f\"Name: {mid['name'].title()}\")\n",
    "print(f\"Company: {mid['company']}\")\n",
    "print(f\"Service assignment preference: {mid['preference']}\\n\")\n",
    "      \n",
    "mid = midshipmen[3]\n",
    "print(f\"Name: {mid['name'].title()}\")\n",
    "print(f\"Company: {mid['company']}\")\n",
    "print(f\"Service assignment preference: {mid['preference']}\\n\")\n",
    "      \n",
    "mid = midshipmen[4]\n",
    "print(f\"Name: {mid['name'].title()}\")\n",
    "print(f\"Company: {mid['company']}\")\n",
    "print(f\"Service assignment preference: {mid['preference']}\\n\")      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Refactor the code above by following these steps:\n",
    "\n",
    "1. Write a function `print_info` that takes a dictionary containing a midshipman's information as input, and prints the midshipman's information in a format similar to above. Assume that the input dictionary has keys `name`, `company`, and `preference`. The function should print each piece of information on a separate line, like this:\n",
    "\n",
    "    ```\n",
    "    Name: midshipman's name\n",
    "    Company: midshipman's company number\n",
    "    Service assignment preference: midshipman's preference\n",
    "    ```\n",
    "\n",
    "      Without comments or extra blank lines, you should be able to define this function in 4 lines.\n",
    "\n",
    "\n",
    "2. Write a `for` loop that iterates over the list `midshipmen` defined above, and prints each midshipman's information using the `print_info` function you defined earlier. Without comments or extra blank lines, you should be able to write this `for` loop in 2 lines.\n",
    "\n",
    "Hopefully, your new code is more compact, less repetitive, and easier to read than the code above!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Foraker\n",
      "Company: 3\n",
      "Service assignment preference: NFO\n",
      "\n",
      "Name: Uhan\n",
      "Company: 17\n",
      "Service assignment preference: Marine Ground\n",
      "\n",
      "Name: Traves\n",
      "Company: 11\n",
      "Service assignment preference: Nuke SWO\n",
      "\n",
      "Name: Phillips\n",
      "Company: 5\n",
      "Service assignment preference: SWO\n",
      "\n",
      "Name: Svirsko\n",
      "Company: 25\n",
      "Service assignment preference: Navy Pilot\n",
      "\n"
     ]
    }
   ],
   "source": [
    "midshipmen = [\n",
    "    {'name': 'foraker', 'company': 3, 'preference': 'NFO'},\n",
    "    {'name': 'uhan', 'company': 17, 'preference': 'Marine Ground'},\n",
    "    {'name': 'traves', 'company': 11, 'preference': 'Nuke SWO'},\n",
    "    {'name': 'phillips', 'company': 5, 'preference': 'SWO'},\n",
    "    {'name': 'svirsko', 'company': 25, 'preference': 'Navy Pilot'}\n",
    "]\n",
    "\n",
    "# Write your code below\n",
    "def print_info(mid):\n",
    "    \"\"\"Prints information about a midshipman from a dictionary.\"\"\"\n",
    "    print(f\"Name: {mid['name'].title()}\")\n",
    "    print(f\"Company: {mid['company']}\")\n",
    "    print(f\"Service assignment preference: {mid['preference']}\\n\")\n",
    "          \n",
    "for mid in midshipmen:\n",
    "    print_info(mid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 2.__ Recall that we can convert degrees Fahrenheit to degrees Celsius with the following formula:\n",
    "\n",
    "$$\n",
    "\\text{degrees Celsius} = \\frac{5}{9} (\\text{degrees Fahrenheit} - 32).\n",
    "$$\n",
    "\n",
    "Write a function named `fahrenheit_to_celsius` that takes a value in degrees Fahrenheit, and returns the equivalent temperature in degrees Celsius."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fahrenheit_to_celsius(deg_f):\n",
    "    \"\"\"Converts deg_f to the equivalent temperature in degrees Celsius, returns the value.\"\"\"\n",
    "    return (5 / 9) * (deg_f - 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with the code cell below. You should see the output:\n",
    "\n",
    "```\n",
    "97 degrees Fahrenheit is equivalent to 36.11 degrees Celsius.\n",
    "```\n",
    "\n",
    "Note that the cell below uses an f-string with a __format specifier__: `{deg_c:.2f}` prints the value of `deg_c`, but with 2 decimal places. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97 degrees Fahrenheit is equivalent to 36.11 degrees Celsius.\n"
     ]
    }
   ],
   "source": [
    "# DO NOT MODIFY THE CODE IN THIS CELL\n",
    "deg_c = fahrenheit_to_celsius(97)\n",
    "print(f\"97 degrees Fahrenheit is equivalent to {deg_c:.2f} degrees Celsius.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 3.__ Recall the `estimate_temperature` function from Lesson 6, that takes the number of field cricket chirps in 15 seconds as input, and outputs the estimated temperature in Fahrenheit. The function is defined in the code cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_temperature(n_chirps):\n",
    "    \"\"\"Estimate temperature based on number of chirps in 15 seconds.\"\"\"\n",
    "    # The number of seconds it took the cricket to chirp n_chirps times\n",
    "    time = 15\n",
    "\n",
    "    # Determine the number of chirps per minute\n",
    "    chirps_per_minute = n_chirps * (60 / time)\n",
    "\n",
    "    # Estimated temperature (in degrees Fahrenheit)\n",
    "    est_temp = (chirps_per_minute + 40) / 4\n",
    "\n",
    "    # Return the answer\n",
    "    return est_temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the function `fahrenheit_to_celsius` you wrote in the problem above, and the function `estimate_temperature` defined in the code cell above, write code that prints the estimated temperature in degrees Celsius when there are 75 chirps in 15 seconds. __Do this in one line of code.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.444444444444446\n"
     ]
    }
   ],
   "source": [
    "print(fahrenheit_to_celsius(estimate_temperature(75)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 4.__  A [triangular number](https://en.wikipedia.org/wiki/Triangular_number) counts objects arranged in an equilateral triangle. The $n$th triangular number is the number of dots in the triangular arrangement with $n$ dots on a side, and is equal to the sum of the $n$ natural numbers from 1 to $n$.  The sequence of triangluar numbers, starting at the 0th triangular number, is\n",
    "<center> 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120, 136, ... </center> \n",
    "\n",
    "There is a formula for the $n$th triangular number:\n",
    "\\begin{equation*}\n",
    "T_n = \\frac{n(n+1)}{2}\n",
    "\\end{equation*}\n",
    "\n",
    "In the code cell below, write a Python function named `triangular_number` that takes `n` as an argument, and returns the `n`th triangular number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def triangular_number(n):\n",
    "    \"\"\"Returns the nth triangular number.\"\"\"\n",
    "    return (n * (n + 1)) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with the code cell below. You should see the output:\n",
    "\n",
    "```\n",
    "The 14th triangular number is 105.0.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 14th triangular number is 105.0.\n"
     ]
    }
   ],
   "source": [
    "# DO NOT MODIFY THE CODE IN THIS CELL\n",
    "my_triangular_number = triangular_number(14)\n",
    "print(f\"The 14th triangular number is {my_triangular_number}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Note.</em> Why are triangular numbers useful? The triangular number $T_n$ measures the number of possible one on one interactions among $n+1$ people. For instance, among $4$ people, there are $T_3 = 6$ possible connections one on one interactions: AB, AC, AD, BC, BD, and CD.\n",
    "\n",
    "<center>\n",
    "<img src=\"img/Triangular.png\">\n",
    "There are $T_3 = 6$ connections among 4 people. \n",
    "</center>\n",
    "\n",
    "Most animals can only manage a small number of relationships to other animals. A group of 4 dogs can monitor the 6 one-on-one relationships in the pack. A group of 15 dogs would have trouble keeping track of the 120 relationships among the pack. The pack would likely splinter into smaller groups. Humans can use language to manage many more relationships but keeping track of the 435 relationships among 30 people would be difficult. This is one reason that military squads tend to be small.\n",
    "\n",
    "Similarly, the $T_{19} = 190$ wires are needed to connect 20 computers to each other directly. This number grows (close to) quadratically: if we double the number of computers, we require approximately four times as many wires. In face, we require $T_{39} = 780$ wires to connect 40 computers directly to each other.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 5.__ Write a function named `buno_frequency` that takes two arguments:\n",
    "\n",
    "1. a list called `aircraft_ids`, consisting of strings representing aircraft identifiers, and\n",
    "2. a string `buno` that represents a specific aircraft identifier.\n",
    "\n",
    "The function should return the number of times the value stored in `buno` appears in the list `aircraft_ids`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buno_frequency(aircraft_ids, buno):\n",
    "    \"\"\"Returns the number of times buno appears in aircraft_ids.\"\"\"\n",
    "    # Initialize frequency to 0\n",
    "    freq = 0\n",
    "    \n",
    "    # Iterate through list of aircraft ids\n",
    "    # Count how many are the same as buno\n",
    "    for i in aircraft_ids:\n",
    "        if i == buno:\n",
    "            freq += 1\n",
    "            \n",
    "    return freq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with the code cell below. You should see the output:\n",
    "\n",
    "```\n",
    "The BUNO 165908 appears 3 times in the list.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The BUNO 165908 appears 3 times in the list.\n"
     ]
    }
   ],
   "source": [
    "# DO NOT MODIFY THE CODE IN THIS CELL\n",
    "aircraft_ids = ['165904', '165908', '165910', '165904', '166902', '165908', \n",
    "                '166902', '166910', '164482', '165908', '165904', '166902']\n",
    "buno = '165908'\n",
    "num_times = buno_frequency(aircraft_ids, buno)\n",
    "print(f\"The BUNO {buno} appears {num_times} times in the list.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 6.__ Write a function named `sum_and_product` that takes a list called `numbers` as input, and returns a list consisting of two values: (1) the sum of the values in `numbers`, and (2) the product of the values in `numbers`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_and_product(numbers):\n",
    "    \"\"\"Returns the sum and product of the values in the list numbers.\"\"\"\n",
    "    my_sum = 0\n",
    "    my_product = 1\n",
    "    \n",
    "    for i in numbers:\n",
    "        my_sum = my_sum + i\n",
    "        my_product = my_product * i\n",
    "\n",
    "    return [my_sum, my_product]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with the code cell below. You should see the output:\n",
    "\n",
    "```\n",
    "The sum of these numbers is 24 and the product of these numbers is -40320.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of these numbers is 24 and the product of these numbers is -40320.\n"
     ]
    }
   ],
   "source": [
    "# DO NOT MODIFY THE CODE IN THIS CELL\n",
    "numbers = [5, 7, -2, 8, 6, -3, 4, -1]\n",
    "output = sum_and_product(numbers)\n",
    "print(f\"The sum of these numbers is {output[0]} and the product of these numbers is {output[1]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 7.__ Look at the code in the cell below. <span class=\"rred\">Before</span> you run the code, what do you think the results will be for the two print statements? Write your answers below, then run the code to see if you were correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `print(x)` will result in the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your answer here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `print(my_value)` will result in the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your answer here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "500\n"
     ]
    }
   ],
   "source": [
    "# ANSWER THE QUESTIONS ABOVE BEFORE RUNNING THIS CELL\n",
    "x = 2\n",
    "def my_function(x):\n",
    "    x = 500\n",
    "    return x\n",
    "\n",
    "my_value = my_function(x)\n",
    "print(x)\n",
    "print(my_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you get the correct results for the two print statements? <span class=\"rred\">Read the aside below.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A very important aside"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Not all variables are accessible from all parts of our code.\n",
    "\n",
    "- The part of our code where a variable is accessible is called its __scope__.\n",
    "\n",
    "- A variable defined inside a function is __local__ to that function: \n",
    "    - It is accessible from the point it is defined until the end of the function.\n",
    "    - It is not acccessible outside the function.\n",
    "\n",
    "- The arguments/parameters in the function definition also behave like local variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 8.__ Look at the code in the cell below.  <span class=\"rred\">Before</span> you run the code, what do you think the results will be for the two print statements? Write your answers below, then run the code to see if you were correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `print(my_name)` will result in the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your answer here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `print(cap_first_name)` will result in the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your answer here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jay Foraker\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'cap_first_name' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-868756c1d1b3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mmy_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfull_name_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlast_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcap_first_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'cap_first_name' is not defined"
     ]
    }
   ],
   "source": [
    "# ANSWER THE QUESTIONS ABOVE BEFORE RUNNING THIS CELL\n",
    "first_name = 'jay'\n",
    "last_name = 'foraker'\n",
    "\n",
    "def full_name_function(a ,b):\n",
    "    cap_first_name = a.title()\n",
    "    cap_last_name = b.title()\n",
    "    full_name = f'{cap_first_name} {cap_last_name}'\n",
    "    return full_name\n",
    "\n",
    "my_name = full_name_function(first_name, last_name)\n",
    "print(my_name)\n",
    "print(cap_first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running the code in the cell above resulted in a `NameError` because `cap_first_name` was <span class=\"rred\">only</span> defined inside the function `full_name_function`.  \n",
    "\n",
    "The cell below contains a copy of the code that produced the error.  Modify the code in the cell below so that the two print statements in the next code cell produces the following output:\n",
    "\n",
    "```Python\n",
    "print(my_name[0])\n",
    "Jay Foraker\n",
    "\n",
    "print(my_name[1])\n",
    "Jay\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MODIFY the code in this cell\n",
    "first_name = 'jay'\n",
    "last_name = 'foraker'\n",
    "\n",
    "def full_name_function(a, b):\n",
    "    cap_first_name = a.title()\n",
    "    cap_last_name = b.title()\n",
    "    full_name = f'{cap_first_name} {cap_last_name}'\n",
    "    return [full_name, cap_first_name]\n",
    "\n",
    "my_name = full_name_function(first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jay Foraker\n",
      "Jay\n"
     ]
    }
   ],
   "source": [
    "# DO NOT MODIFY THE CODE IN THIS CELL\n",
    "# Run this code AFTER you've modified the code in the cell above\n",
    "print(my_name[0])\n",
    "print(my_name[1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}