DS102-Statistical-Programming-in-R/DS102-L3-Variables-Functions-and-For-Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS102 Statistical Programming in R : Lesson Three - Variables, Functions, and For Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS102L3_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS102L3_toc)\n",
    "    * [Page 1 - Introduction](#DS102L3_page_1)\n",
    "    * [Page 2 - Variables](#DS102L3_page_2)\n",
    "    * [Page 3 - Strings](#DS102L3_page_3)\n",
    "    * [Page 4 - Arithmetic Operations](#DS102L3_page_4)\n",
    "    * [Page 5 - Functions](#DS102L3_page_5)\n",
    "    * [Page 6 - Creating Functions](#DS102L3_page_6)\n",
    "    * [Page 7 - Vectors](#DS102L3_page_7)\n",
    "    * [Page 8 - The For Loop](#DS102L3_page_8)\n",
    "    * [Page 9 - Key Terms](#DS102L3_page_9)\n",
    "    * [Page 10 - Hands-On](#DS102L3_page_10)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Introduction<a class=\"anchor\" id=\"DS102L3_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "125edc68-cde0-4ecc-9993-23d69a25f943",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/247057893\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ff160>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('247057893', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "In this lesson, you will begin to learn the fundamentals of using R. You will learn about how the following concepts and operations work in R:\n",
    "\n",
    "* Variables and assigning values to variables\n",
    "* Character strings\n",
    "* Numerical operations\n",
    "* Vectors\n",
    "* Functions \n",
    "* For loops\n",
    "\n",
    "By the end of this lesson, you will be able to create your very own function and for loop to compute sphere diameter for a vector in R.\n",
    "\n",
    "As you go through, type the examples into RStudio and verify that you get the results shown. This will help you understand how R works.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Variables<a class=\"anchor\" id=\"DS102L3_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b001f3d-0f7c-4870-9d93-3f6bc710de1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671179\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ffb20>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671179', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg2tutorial.zip)**.\n",
    "\n",
    "# A Note About Errors\n",
    "\n",
    "Everybody who codes makes errors. Don't be afraid of them. The goal, when you are learning to program, should not be to never make an error, but to make lots of them so you can learn what they look like so you can fix them.\n",
    "\n",
    "One of the most difficult parts of learning to program in any language is to connect the error messages produced by running your code to the error in your code, understand what the error is, and fix it.\n",
    "\n",
    "So, as you go through this and subsequent lessons, when something works, congratulate yourself, but don't stop there. Take some time to break your code and see what happens. Remove a quote or a semicolon. Change a variable name. Change a number. As you do this, you will learn what errors look like, and will be better able to fix them.\n",
    "\n",
    "---\n",
    "\n",
    "## Variables and Assignments\n",
    "\n",
    "The R language operates on named objects. Objects can be as simple as a single number, or as complex as the information generated by a complicated statistical analysis. You will start with very simple objects and work with more complex ones as you advance. The name of an object is referred to as a *variable*. Conceptually, a variable is a named place to store something. [Examples covered in this lesson](./Examples/DS102L3-Examples-variables-functions-forLoops.ipynb)\n",
    "\n",
    "---\n",
    "\n",
    "## Naming Conventions for Variables\n",
    "\n",
    "R is frighteningly permissive about variable names. It is not a good idea, however, to use some of the variable names that R will allow you to use, since this will teach you bad habits in other languages you'll use later on.  You will be assured that your variable names will work on any implementation of R if you stick to the following rules:\n",
    "\n",
    "* Use only the letters a-z (as well as capital letters A-Z), the digits 0-9, periods, and underscores. \n",
    "\n",
    "    <div class=\"panel panel-info\">\n",
    "        <div class=\"panel-heading\">\n",
    "            <h3 class=\"panel-title\">Tip!</h3>\n",
    "        </div>\n",
    "        <div class=\"panel-body\">\n",
    "            <p>R does distinguish between lower-case letters and upper-case letters.</p>\n",
    "        </div>\n",
    "    </div>\n",
    "\n",
    "* Variable names must start with a letter or a period.\n",
    "\n",
    "* If the variable name starts with a period, the second character can not be a digit.\n",
    "\n",
    "Variable names can be up to 10,000 characters in length, but it is generally considered to be good practice to use much shorter variable names. The shorter, the better, as long as you can deduce meaning from it.  This is so that you are less likely to make mistakes as you type variable names in repetitively.\n",
    "\n",
    "Unlike many other programming languages, which do not allow periods to be part of a variable name (Python, for example), in R a period can be part of a variable name. Traditionally in R, variable names made up of multiple words are connected by periods: \n",
    "\n",
    "```this.is.a.long.variable.name.made.of.words.connected.by.periods```\n",
    "\n",
    "The above is a valid variable name. In many other programming languages, variable names are created by joining words with underscores. This can also be done in R: \n",
    "\n",
    "```this_is_a_long_variable_name_made_of_words_connected_by_underscores```\n",
    "\n",
    "So the above is a valid variable name, too.  Even though R will allow periods, you are encouraged to use underscores or just capitalization to denote new words, so that you're not having to change how you operate once you learn Python.\n",
    "\n",
    "Here's what capitalization might look like: \n",
    "\n",
    "```ThisIsALongVariableNameMadeOfWords```\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Fun Fact!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Capitalization like what is done above is referred to as \"Camel Case\" because it's like looking at the humps of a camel.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "One way to think about variables is to imagine a row of cubbies at the back of a grade school classroom, where each cubby is labeled by a name; each cubby represents a variable. Each cubby (variable) can hold an object. As a program executes, it gets objects from cubbies, does computations with these objects, and perhaps creates new objects from these computations, which are then stored in a new cubby.\n",
    "\n",
    "![Cubbies in a classroom holding various items.](Media/calculating1.jpg)\n",
    "\n",
    "An assignment statement assigns an object to a variable; in other words, it gives the object a name. Assignment statements can be built using the following symbols: \n",
    "\n",
    "* <-\n",
    "* =\n",
    "* -> \n",
    "\n",
    "For example: \n",
    "\n",
    "* The assignment statement x <- 3 creates a variable x and stores 3 in it.\n",
    "* The assignment statement y = 7 creates a variably y and stores 7 in it.\n",
    "* The assignment statement 11 -> z creates a variable z and stores 11 in it.\n",
    "\n",
    "R is quite unusual in that it has three different ways to indicate assignment; most programming languages only have one. In most programming languages, you think of the variable on the left being assigned the value on the right, as in the top two assignment statements. But R also allows us to assign the value on the left to a variable on the right, as in the last assignment statement.\n",
    "\n",
    "To implement your first assignment statement, start RStudio if it is not already started. Then enter the following assignment into the Console window:\n",
    "\n",
    "```{r}\n",
    "x <- 3\n",
    "```\n",
    "\n",
    "Your RStudio window should look something like this:\n",
    "\n",
    "![An R studio window showing three panes, one for console, one for environment and history, and one for files, plots, packages, help, and viewer.](Media/L02-SimpleAssignment.png)\n",
    "\n",
    "The list of values in the ```Environment``` tab shows the variable x and the value that is assigned to it, namely 3. Try the other two assignment statements above and verify that the correct number is assigned to the correct variable. Now try to generate an error message by changing the direction of the -> in one of your assignment statements.\n",
    "\n",
    "From here on, in the examples, you will see the statement you should type into the Console window of RStudio and the response you will get, but you typically won't see images of RStudio. \n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0af7d60d-7bab-4b65-b262-9bdc024cfde4",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import *\n",
    "    from ipynb.fs.full.DS102Questions import *\n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import *\n",
    "    from ipynb.fs.full.DS102Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "60cc124e-a121-48bb-a8e2-b6db0da15854",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2e6d2e34025342ec8c85a9c5a86eca60",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What is a variable?\\n', 'output_type': 'stream'}…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e9cc549a339435a87d18aab046a50d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Which of the following is NOT a valid naming con…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c6cfb0d602924ade9812704f0658d541",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. Which of the following is NOT a way to assign va…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "15e70c6c2ef84784a6b1e1fa289ef80f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '4. Consider the assignment:\\n \\n \\x1b[31;1mage.of.a…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eaa782dae55b42588f59c22d003216df",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '5. Consider the assignment:\\n \\n \\x1b[31;1m21 -> ba…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1dbff5e1fa7c4cf995ed2994069e48e1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '6. True or False? \\n     Once Created, your variabl…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P2Q1, L3P2Q2, L3P2Q3, L3P2Q4, L3P2Q5, L3P2Q6)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Strings<a class=\"anchor\" id=\"DS102L3_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3cf62499-81ef-4980-a055-324cfe085d90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671296\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ffa30>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671296', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "\n",
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg3tutorial.zip)**.\n",
    "\n",
    "# Strings\n",
    "\n",
    "So far, you have only assigned numbers to variables. But R has the capability to represent many more types of data in addition to numbers. In this section, strings, or character data, are introduced. \n",
    "\n",
    "In computer programming, a sequence of characters is often called a *string*. Strings are used for many reasons, including to represent categorical data values, to represent column names in data tables, and to represent labels in charts and graphs.\n",
    "\n",
    "Strings can be created in R by enclosing the string in single quotes ```'``` or double quotes ```\"```. For example, this is a valid string: \"Hello World!\" If you enter this string into the R Console, R will print it (with the quotes):\n",
    "\n",
    "```{r}\n",
    "\"Hello World!\"\n",
    "```\n",
    "\n",
    "[1] \"Hello World!\"\n",
    "\n",
    "Strings can be assigned to variables just like numbers. This statement assigns the string to the variable ```h```:\n",
    "\n",
    "```{r}\n",
    "h <- \"Hello World!\"\n",
    "```\n",
    "### [Errata4](Errata/DS102-Change-Log.ipynb)\n",
    "<a class=\"anchor\" id=\"Run_button\"></a>\n",
    "\n",
    "As with assignments of numbers, R does not print the result of an assignment. R will print the value of a variable when you type it into the Console. So entering ```h``` into the console and pressing the Run button produces the following:\n",
    "\n",
    "```{r}\n",
    "h\n",
    "```\n",
    "\n",
    "[1] \"Hello World!\"\n",
    "\n",
    "You can also use the ```print()``` function to print the value of a variable. If you enter ```print(h)``` into the console, you get the same output as you got when just entering ```h```:\n",
    "\n",
    "```{r}\n",
    "print(h)\n",
    "```\n",
    "\n",
    "[1] \"Hello World!\"\n",
    "\n",
    "You can combine two strings into a single one using the ```paste()``` function:\n",
    "\n",
    "```{r}\n",
    "f <- \"Hello\"\n",
    "g <- \"World!\"\n",
    "paste(f, g)\n",
    "```\n",
    "\n",
    "[1] \"Hello World!\"\n",
    "\n",
    "This means that you get the output in only one line, instead of two.\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "39acba87-5abd-4f8b-a597-33e430b3b201",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8be2f69cafda4a69bd94b7d87443531a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which of the following R statements will create …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c5fff15e5334e5cab2e93dd5ab4be11",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Suppose you have two variables: \\x1b[31;1mfirst.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P3Q1, L3P3Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Arithmetic Operations<a class=\"anchor\" id=\"DS102L3_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "914b0c4b-7963-4970-961f-b59def1103e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671154\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ffa60>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671154', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg4tutorial.zip)**.\n",
    "\n",
    "# Arithmetic Operations\n",
    "\n",
    "Like most other computational environments, R can do computations on data values, including those stored in variables. You can compute the sum of two numbers as follows; R will provide the following output:\n",
    "\n",
    "```{r}\n",
    "2+3\n",
    "```\n",
    "\n",
    "[1] 5\n",
    "\n",
    "You can also compute the sum of two numbers that are stored as variables:\n",
    "\n",
    "```{r}\n",
    "x <- 4\n",
    "y <- 7\n",
    "x + y\n",
    "```\n",
    "\n",
    "[1] 11\n",
    "\n",
    "R implements all of the usual arithmetic operators:\n",
    "\n",
    "* **Addition:** x + y\n",
    "* **Subtraction:** x - y\n",
    "* **Multiplication:** x * y\n",
    "* **Division:** x / y\n",
    "* **Raising to a Power:** x ^ y\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>The spaces on both sides of the operator are optional; R generally ignores spaces that are not inside quotation marks. x+y works exactly like x + y. Most programmers put spaces around operators to improve readability.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Order of Operations\n",
    "\n",
    "These arithmetic operators have the following precedence. Raising to a power is done first, followed by multiplication and division, and finally addition and subtraction.\n",
    "\n",
    "You may recall the acronym \"PEMDAS\" from math classes, where PEMDAS indicates the order of operation. PEMDAS stands for:\n",
    "\n",
    "* Parentheses\n",
    "* Exponents\n",
    "* Multiplication\n",
    "* Division\n",
    "* Addition\n",
    "* Subtraction\n",
    "\n",
    "You can easily remember this with a pneumonic often taught still: Please Excuse My Dear Aunt Sally, where each letter in the pneumonic helps remind you of which operation will come next.  \n",
    "\n",
    "PEMDAS is the same order that R (and most programming languages) uses to determine which operation to do when.\n",
    "\n",
    "So, when evaluating this:\n",
    "\n",
    "```text\n",
    "3^4 * 2 + 1\n",
    "```\n",
    "\n",
    "R first computes 3 ^ 4, which is 81. It then multiplies 81 by 2 to get 162, then adds 1 to get 163.\n",
    "\n",
    "You can change the order in which operations are performed by using parentheses: ```(``` and ```)```. For example, in the below: \n",
    "\n",
    "```text\n",
    "3 ^ (4 * 2 + 1)\n",
    "```\n",
    "\n",
    "R first computes 4 * 2, which is 8, then adds 1 to get 9, and finally computes 3 ^ 9, which is 19683.\n",
    "\n",
    "A sequence of variables, numbers, arithmetic operations, and functions (more on functions in a bit) is called an expression. If an expression is used without an assignment, the result is printed, but not saved (sort of):\n",
    "\n",
    "```{r}\n",
    "4 ^ 2 + 3 ^ 2\n",
    "```\n",
    "\n",
    "[1] 25\n",
    "\n",
    "The result of the computation, 25, is printed, but it is not easily accessible going forward. You can save the result of an expression by assigning it to a variable:\n",
    "\n",
    "```{r}\n",
    "s <- 4 ^ 2 + 3 ^ 2\n",
    "```\n",
    "\n",
    "This statement computes the value of the expression and stores it in the variable ```s```, but it does not print it. As you learned earlier, you can see the value that was computed by typing the variable ```s```:\n",
    "\n",
    "```{r}\n",
    "s\n",
    "```\n",
    "\n",
    "[1] 25\n",
    "\n",
    "---\n",
    "\n",
    "## Example: Computing a *z*-Score\n",
    "\n",
    "Next, you will use R to do a statistical calculation from the Basic Statistics module, namely computing a *z*-score.\n",
    "\n",
    "In the Basic Statistics module you were informed that in Ghana, the height of a young adult woman is normally distributed with a mean of 159.0 cm and a standard deviation of about 4.9 cm.\n",
    "\n",
    "Gabianu is a college student originally from Ghana, and she stands 169.0 cm tall. You can compute the *z*-score for Gabianu's height using this formula:\n",
    "\n",
    "![The formula to find the z score. Z equals x minus mu divided by sigma.](Media/L02-zscore.png)\n",
    "\n",
    "You first define R variables for each of the quantities on the right side of the formula:\n",
    "\n",
    "```{r}\n",
    "x <- 169.0\n",
    "mu <- 159.0\n",
    "sigma <- 4.9\n",
    "```\n",
    "\n",
    "You can now compute the *z*-score with this expression:\n",
    "\n",
    "```{r}\n",
    "(x - mu) / sigma\n",
    "```\n",
    "\n",
    "[1] 2.040816\n",
    "\n",
    "Note that the parentheses are necessary in the computation of the *z*-score. The reason for this is that you must first subtract mu from x, then divide the difference by sigma.\n",
    "\n",
    "If you leave the parentheses out of the expression, it would look like this: x - mu / sigma. Because division has a higher precedence than subtraction, R would divide mu by sigma first, then subtract this quotient from x. If you type this expression into R without the parentheses, you get the following:\n",
    "\n",
    "```{r}\n",
    "x - mu / sigma\n",
    "```\n",
    "\n",
    "[1] 136.551\n",
    "\n",
    "You can clearly see that this is different than the correct answer above.\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded.\n",
    "<p style=\"text-align: center\">\n",
    "  <img src=\"Media/L02-circleArea.png\" alt=\"Drawing\" style=\"width: 100px;\"/>\n",
    "</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1e8166f0-3c4c-4f30-aaa7-10e6f2513d8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "21f5d8009b87416d96e062257850d37a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. The area of a circle is given by the following f…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d2b4e1f0ce714dfab5c2cf8e9d02116b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. The sample variance can be computed from the sam…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f57a749bcb9c4661bbb08858ffe83f92",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': \"3. Gabianu's friend from Ghana is Rashida. Rashida …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P4Q1, L3P4Q2, L3P4Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Functions<a class=\"anchor\" id=\"DS102L3_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "86873b70-3154-4fef-b713-81478bd2ef6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671254\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ffd90>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671254', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg5tutorial.zip)**.\n",
    "\n",
    "# Functions\n",
    "\n",
    "In most programming languages, a function relates inputs (also called arguments) to an output; in other words, a function produces a value for each possible value(s) of their argument(s).  You can think of a function as the main \"do-er\" - it is a command that will be done to the data you feed the function. A function performs a specific programming task.\n",
    "\n",
    "You have already worked with functions in the Basic Statistics module, even though they weren't thought of as such. For example, you had to compute the square root of 16. R has a function built in that will compute a square root; this function is ```sqrt()```. Notice that a function has a name followed by parentheses; the function's argument goes in the parentheses.\n",
    "\n",
    "You can compute the square root of 16 in R as follows:\n",
    "\n",
    "```{r}\n",
    "sqrt(16)\n",
    "```\n",
    "\n",
    "[1] 4\n",
    "\n",
    "In this computation, 16 is the argument of the ```sqrt()``` function. The ```sqrt()``` function returns the value 4, which is printed. You could save the returned value in a variable ```t```:\n",
    "\n",
    "```{r}\n",
    "t <- sqrt(16)\n",
    "t\n",
    "```\n",
    "\n",
    "[1] 4\n",
    "\n",
    "The argument of a function can also be a variable; in the following, you will set the value of ```w``` to be 2, then compute its square root:\n",
    "\n",
    "```{r}\n",
    "w <- 2\n",
    "sqrt(w)\n",
    "```\n",
    "\n",
    "[1] 1.414214\n",
    "\n",
    "R provides almost every mathematical function you are ever likely to want to compute. \n",
    "\n",
    "In addition, R provides many functions specifically for statistical analysis. You'll be introduced to these in the example below.\n",
    "\n",
    "Many of the R commands you have learned are actually implemented in R as functions. For example, ```print()``` is actually a function that prints its argument in the Console window. ```help()``` is a function that brings up help information about its argument. ```paste()```, used earlier in this lesson, is a function that takes two or more strings as arguments and combines them into a single string.\n",
    "\n",
    "---\n",
    "\n",
    "## Example: Computing a Percentile from a *z*-Score\n",
    "\n",
    "In the Basic Statistics module, you used an applet to compute a percentile from a *z*-score. You had the following problem:\n",
    "\n",
    "Suppose you took a standardized exam, and the mean score is 440 with a standard deviation of 23. Your score is 472...what percentile is that?\n",
    "\n",
    "The first step in solving this problem is to compute the *z*-score. From the previous example, you know how to do this:\n",
    "\n",
    "```{r}\n",
    "x <- 472\n",
    "mu <- 440\n",
    "sigma <- 23\n",
    "z.score <- (x - mu) / sigma\n",
    "z.score\n",
    "```\n",
    "\n",
    "[1] 1.391304\n",
    "\n",
    "So the *z*-score for this example is 1.391304.\n",
    "\n",
    "Here is a random question: why could you not give the variable that stores the *z*-score the name *z*-score? Try doing this in R and see what happens.  You get an error because variable names in R cannot contain dashes.\n",
    "\n",
    "```pnorm()``` is an R function that computes percentiles from *z*-scores for the normal distribution. You want to know what percentage of scores will be below 472. This is the same as the area under the standard normal density to the left of 1.391304, and is the blue part in this graph:\n",
    "\n",
    "![A normal distribution with z scores at negative one point three nine one and one point three nine one. The z scores are indicated with vertical lines on the distribution. The area to the left of the one point three nine one vertical line is shaded in a different color.](Media/L02-PercentileBelow.png)\n",
    "\n",
    "You can compute this area using ```pnorm()``` as follows. The argument to ```pnorm()``` is the ```z.score``` variable that was computed above:\n",
    "\n",
    "```{r}\n",
    "pnorm(z.score)\n",
    "```\n",
    "\n",
    "[1] 0.9179334\n",
    "\n",
    "You can convert this number to a percent by multiplying by 100:\n",
    "\n",
    "```{r}\n",
    "pnorm(z.score) * 100\n",
    "```\n",
    "\n",
    "[1] 91.79334\n",
    "\n",
    "This tells you that the score of 472 is greater than 91.79334% of the scores.\n",
    "\n",
    "```pnorm()``` can also compute the area under the standard normal density to the right of 1.391304, or the blue part in the graph below:\n",
    "\n",
    "![A normal distribution with z scores at negative one point three nine one and one point three nine one. The z scores are indicated with vertical lines on the distribution. The area to the right of the one point three nine one vertical line is shaded in a different color.](Media/L02-PercentileAbove.png)\n",
    "\n",
    "You compute this as follows:\n",
    "\n",
    "```{r}\n",
    "pnorm(z.score, lower.tail = FALSE)\n",
    "```\n",
    "\n",
    "[1] 0.08206658\n",
    "\n",
    "The argument ```lower.tail = FALSE``` indicates to ```pnorm()``` that you want the upper tail (the area to the right), rather than the lower tail (the area to the left). You can convert this result to a percent by multiplying it by 100:\n",
    "\n",
    "```{r}\n",
    "pnorm(z.score, lower.tail = FALSE) * 100\n",
    "```\n",
    "\n",
    "[1] 8.206658\n",
    "\n",
    "This tells you that the score of 472 is less than 8.206658% of the scores.\n",
    "\n",
    "```pnorm()``` can even save you the effort of computing the *z*-score. You can supply the mean and standard deviation of the normal distribution as arguments to ```pnorm()```, and it will compute the lower tail area directly from the score:\n",
    "\n",
    "```{r}\n",
    "pnorm(472, mean=440, sd=23)\n",
    "```\n",
    "\n",
    "[1] 0.9179334\n",
    "\n",
    "mean is the name ```pnorm()``` uses for the mean, and sd is the name ```pnorm()``` uses for the standard deviation. You can see that the value returned by ```pnorm()``` is the same as the one you obtained using the *z*-score. You can compute the upper tail area as well:\n",
    "\n",
    "```{r}\n",
    "pnorm(472, mean=440, sd=23, lower.tail = FALSE)\n",
    "```\n",
    "\n",
    "[1] 0.08206658\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "82ee0162-24b7-4f58-a9aa-37876b6b49ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d93d4eb49ff24a6fae0aff6ef696d686",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What is a function?\\n', 'output_type': 'stream'}…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a82ecd9d748f45d8ad44fc2afc2dcedc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. True or False? \\nAn argument is also known as th…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dda60154ac01429a8b6aa648bf7b1aca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. The sample standard deviation can be computed fr…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P5Q1, L3P5Q2, L3P5Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Creating Functions<a class=\"anchor\" id=\"DS102L3_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a1be862-4f44-427c-960e-64c1f9c2ac5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671206\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ff100>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671206', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg6tutorial.zip)**.\n",
    "\n",
    "# Creating Functions\n",
    "\n",
    "You have used a few functions, such as ```sqrt()```.  However, it can be helpful to define your own functions that take one or more arguments and compute a value. R can do this.\n",
    "\n",
    "---\n",
    "\n",
    "## A Function to Convert Temperatures\n",
    "\n",
    "As an example, suppose you have a data set that includes temperatures measured in degrees Fahrenheit. And suppose you need to convert these temperatures to degrees Celsius. Do a bit of searching online, and you'll discover that the formula to convert a temperature from Fahrenheit to Celsius is the following:\n",
    "\n",
    "![The formula to convert Fahrenheit to Celsius. T C equals open parentheses T F minus thirty two close parentheses times five ninths.](Media/L03-FahrenheitToCelsius.png)\n",
    "\n",
    "In this formula, TC is the temperature in degrees Celsius, and TF is the temperature in degrees Fahrenheit. With this formula and mastery of Lesson 2, you can convert a given temperature from degrees Fahrenheit to degrees Celsius.\n",
    "\n",
    "But suppose you want to convert many temperatures? You can make a function that will do this conversion for us. You will call the function ```f.to.c()```. It will have one argument (the temperature in degrees Fahrenheit) and return the corresponding temperature in degrees Celsius.\n",
    "\n",
    "Start by creating a new, empty script file by using the ```File -> New File``` menu and selecting ```R Script.``` You can then enter your function into the editor window as follows:\n",
    "\n",
    "```{r}\n",
    "f.to.c <- function(TF){\n",
    "    (TF - 32) * 5 / 9\n",
    "}\n",
    "```\n",
    "\n",
    "Now add a line that calls ```f.to.c()``` with an argument of 73 and assigns the result to the variable ```temp.in.c.```.\n",
    "\n",
    "```{r}\n",
    "temp.in.c <- f.to.c(73)\n",
    "```\n",
    "\n",
    "Then execute the whole script file by clicking on the Source button. R runs the script, and you see in the Environment pane that a new variable, ```temp.in.c``` has been created. You can find the value of ```temp.in.c``` by typing it in the Console pane:\n",
    "\n",
    "```{r}\n",
    "temp.in.c\n",
    "```\n",
    "\n",
    "[1] 22.77778\n",
    "\n",
    "Now that the overall function is laid out, you will examine the function in detail. The first line is:\n",
    "\n",
    "```{r}\n",
    "f.to.c <- function(TF) {\n",
    "```\n",
    "\n",
    "```f.to.c``` is the name of the function. ```f.to.c``` is actually a variable, and rather than assigning a number or a string to it, you are assigning a function to it. That is indicated by the assignment operator ```<-```. \n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>In addition to holding numbers and strings, variables can hold many different objects, including functions.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "Then, you have ```function(TF)```. ```function()``` indicates that you are creating a function. ```(TF)``` shows that the function will have one argument, named ```TF```. This line finishes with an open brace ```{```, which indicates that you are beginning the definition of the function.\n",
    "\n",
    "The second line of the function is:\n",
    "\n",
    "```{r}\n",
    "(TF - 32) * 5 / 9\n",
    "```\n",
    "\n",
    "This is an expression that actually converts from Fahrenheit to Celsius; if you look at the formula, you will see that this expression is the right hand side of the formula. This line of the function is the last line of code in the function. (It is also the first line of code, and actually the only line of code.) The value computed by the last line of code is the value that is returned by the function.\n",
    "\n",
    "The last line of the function is just a closing brace ```}```, which signifies the end of the function.\n",
    "\n",
    "When you call the function with ```f.to.c(73)```, the function sets ```TF``` to a value of 73. It then executes the next line of code, which subtracts 32 from TF and multiplies the result by 5/9, giving the value 22.77778. This is the value that is returned by the function.\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d15bcec0-d264-4392-a66d-9d3093217d02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "073855611ce5400fb1ff1f76147bc45f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What command is required when creating your own …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f01f71a6aa674cc3974d35ce3d8192cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. What do the curly braces \\x1b[31;1m{}\\x1b[0m ind…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P6Q1, L3P6Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Vectors<a class=\"anchor\" id=\"DS102L3_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c2b186f4-e458-4f5d-880b-250d5c32cf62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671276\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4ffe20>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671276', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg7tutorial.zip)**.\n",
    "\n",
    "# Introduction to Vectors\n",
    "\n",
    "A numerical *vector* is an ordered collection of numbers. Ordered means that there is a first number, a second number, and so on to the last number. Each number in the vector is called an *element*.\n",
    "\n",
    "You can create a vector of numbers using the ```c()``` function; its default operation is to combine its arguments into a vector. Suppose you measured the height in centimeters of six people and got the following six measurements: 171, 192, 183, 177, 154, and 176. You can create a vector of these heights as follows:\n",
    "\n",
    "```{r}\n",
    "c(171, 192, 183, 177, 154, 176)\n",
    "```\n",
    "\n",
    "[1] 171 192 183 177 154 176\n",
    "\n",
    "You can assign this vector to the variable ```heights```:\n",
    "\n",
    "```{r}\n",
    "heights <- c(171, 192, 183, 177, 154, 176)\n",
    "```\n",
    "\n",
    "R allows you to easily create vectors that are sequences of numbers. These types of vectors are especially useful in for loops. You can use the ```:``` operator to create a sequence of numbers going from 1 to 10:\n",
    "\n",
    "```{r}\n",
    "1:10\n",
    "```\n",
    "\n",
    "[1] 1 2 3 4 5 6 7 8 9 10\n",
    "\n",
    "You can make descending sequences of numbers as well:\n",
    "\n",
    "```{r}\n",
    "7:2\n",
    "```\n",
    "\n",
    "[1] 7 6 5 4 3 2\n",
    "\n",
    "You can assign the vectors created by the ```:``` operator to variables, just like any other vector:\n",
    "\n",
    "```{r}\n",
    "s <- 2:5\n",
    "s\n",
    "```\n",
    "\n",
    "[1] 2 3 4 5\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3ec67756-f722-4f62-8cd9-d059cc66defe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ddedbc37adc14892a1d92a9b2d52f6be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What command creates a vector of non-sequential …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P7Q1)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - The For Loop<a class=\"anchor\" id=\"DS102L3_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3d574a2f-2b73-4eef-a9d9-bc11bf25e259",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/326671216\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1edbf4fffa0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Introduction to R\n",
    "VimeoVideo('326671216', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "\n",
    "The transcript for the above topic tutorial video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO102-L03-pg8tutorial.zip)**.\n",
    "\n",
    "\n",
    "# The For Loop\n",
    "\n",
    "R, like most programming languages, has commands that allow you to repeat computations or actions. The most widely used command to do this is call a *for loop*. It's format is *for* this, in *that*, do *something*. \n",
    "\n",
    "---\n",
    "\n",
    "## An Everyday Example\n",
    "\n",
    "Sometimes the need exists to perform a certain task multiple times until some condition is met. For example, when baking cookies, a recipe may call for 4 cups of flour. The bowl starts with 0 cups of flour, then a baker will scoop a cup and pour it into the bowl. At this point, the bowl now contains 1 cup of flour. The baker needs to repeat the steps of scooping and pouring flour until the number of cups of flour in the bowl is equal to the number of cups needed for the recipe.\n",
    "\n",
    "The scooping of flour is an example of a loop. The baker performs a series of operations until they meet a certain condition. The operations are the scooping and pouring of flour, and the condition is that the cups of flour in the bowl need to match the quantity the recipe needs.\n",
    "\n",
    "If you were to write this out, then you would have something like:\n",
    "\n",
    "```text\n",
    "for flour_cups in bowl\n",
    "scoop until flour_cups=4\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Your First For Loop\n",
    "\n",
    "Suppose that you want to count from 1 to 6, printing each number on its own line. You open a new script file in the editor, and create a for loop that looks like this:\n",
    "\n",
    "```{r}\n",
    "for (n in 1:6){\n",
    "    print(n)\n",
    "}\n",
    "```\n",
    "\n",
    "When you click on the Source button, the for loop executes and prints the following:\n",
    "\n",
    "```text\n",
    "[1] 1\n",
    "[1] 2\n",
    "[1] 3\n",
    "[1] 4\n",
    "[1] 5\n",
    "[1] 6\n",
    "```\n",
    "\n",
    "When the for loop executes, it does the following: \n",
    "\n",
    "1. ```1:6``` creates a vector of six values starting with one and going to six.\n",
    "\n",
    "2. *n* is assigned to be the first value in the vector, which is 1. \n",
    "\n",
    "3. The statement ```print(n)``` is executed; since *n* is 1, it prints 1.\n",
    "\n",
    "4. Then *n* is assigned to be the second value in the vector, which is 2. The print statement is executed again; since *n* is 2, it prints 2.\n",
    "\n",
    "This process repeats four more times as *n* is assigned 3, 4, 5, and 6 in turn. Finally, there are no more values in the vector, so the for loop is done.\n",
    "\n",
    "The statements in the for loop between the open brace ```{``` and close brace ```}``` are called the body of the loop. There may be more than one statement in the body. Suppose you wish to extend your for loop to print both the number and the number squared. You could do that with the following for loop:\n",
    "\n",
    "```{r}\n",
    "for (n in 1:6){\n",
    "    print(n)\n",
    "    print(n^2)\n",
    "}\n",
    "```\n",
    "\n",
    "![A R studio editor pane showing a for loop. For open parentheses n in one colon six close parentheses open bracket print open parentheses n close parentheses print open parentheses n caret 2 close parentheses close bracket.](Media/L03-ForLoop2.png)\n",
    "\n",
    "When you click on the the Source button, the for loop prints the following:\n",
    "\n",
    "[1] 1\n",
    "[1] 1\n",
    "[1] 2\n",
    "[1] 4\n",
    "[1] 3\n",
    "[1] 9\n",
    "[1] 4\n",
    "[1] 16\n",
    "[1] 5\n",
    "[1] 25\n",
    "[1] 6\n",
    "[1] 36\n",
    "\n",
    "At this point, you may have become weary of R printing a [1] in front of every number you print. You can use the ```cat()``` function to print numbers without the [1] in front of them.\n",
    "\n",
    "Unfortunately, the ```cat()``` function prints only its arguments; unless you include spaces or new lines specifically as arguments, it will not print them. You can change your for loop to print each number and its square on the same line, without the [1] values, as follows:\n",
    "\n",
    "```{r}\n",
    "for (n in 1:6){\n",
    "    cat(n, \" \")\n",
    "    cat(n^2, \"\\n\")\n",
    "}\n",
    "```\n",
    "\n",
    "When you execute this for loop, it prints the following:\n",
    "\n",
    "1 1\n",
    "2 4\n",
    "3 9\n",
    "4 16\n",
    "5 25\n",
    "6 36\n",
    "\n",
    "The strange string ```\"\\n\"``` inserts a new line into the output; without it, all of the numbers would be printed on the same line.\n",
    "\n",
    "---\n",
    "\n",
    "## Example: Converting Many Temperatures\n",
    "\n",
    "The previous example, while instructive, is not very useful (unless you have a need to know the first six integers and their squares and cannot remember them).\n",
    "\n",
    "In this example, you will use a for loop to convert many temperatures from Fahrenheit to Celsius using the function you created earlier. You will first create a vector of temperatures, then use a for loop to iterate through each temperature and convert it.\n",
    "\n",
    "Later, you'll learn an easier and more efficient way to do this. However, this is an excellent example of how a for loop can be used to compute many things.\n",
    "\n",
    "Create the following script file:\n",
    "\n",
    "```{r}\n",
    "f.to.c <- function(TF) {\n",
    "    (TF - 32) * 5 / 9\n",
    "}\n",
    "\n",
    "f.temps <- c(-40, 0, 32, 100, 212, 400)\n",
    "for (f in f.temps) {\n",
    "    c <-f.to.c(f)\n",
    "    cat(f, \" \", c, \"\\n\")\n",
    "}\n",
    "```\n",
    "\n",
    "Lines 1-3 define the function ```f.to.c()```; this definition is exactly the same as when you introduced it earlier in this lesson.\n",
    "\n",
    "Line 5 creates a vector of temperatures in degrees Fahrenheit and assigns this vector to the variable ```f.temps```. These temperatures are the values that will be converted from Fahrenheit to Celsius.\n",
    "\n",
    "Line 6 starts the for loop.\n",
    "\n",
    "Lines 7 and 8 are the body of the for loop.\n",
    "\n",
    "The for loop operates as follows. When Line 6 is executed, the variable ```f``` is assigned the first temperature in the vector ```f.temps```, which is -40.\n",
    "\n",
    "Then, in Line 7, the ```f.to.c()``` function is called with this value of ```f```; it converts this value to Celsius and assigns it to the variable ```c```.\n",
    "\n",
    "In Line 8, the Fahrenheit temperature in ```f``` and the Celsius temperature in ```c``` are printed on the same line.\n",
    "\n",
    "After this is done, the for loop goes back to Line 6 and assigns the next value in ```f.temps to f```; this value is 0. This value is converted to Celsius and printed in Lines 6 and 7. This process is repeated for all the values in ```f.temps```.\n",
    "\n",
    "When you click on the Source button, you get the following output:\n",
    "\n",
    "-40 -40\n",
    "0 -17.77778\n",
    "32 0\n",
    "100 37.77778\n",
    "212 100\n",
    "400 204.4444\n",
    "\n",
    "It is interesting to note that -40 degrees Fahrenheit is the same temperature as -40 degrees Celsius.\n",
    "\n",
    "---\n",
    "\n",
    "## Summary\n",
    "\n",
    "In this lesson, you learned how to create variables, perform arithmetic using R like a calculator, made your first vector, used and created functions, and created for loops. All of these basics will serve you well as you move forward to start doing more work with data in R.\n",
    "\n",
    "* Functions allow us to perform complex computations with a simple function call.\n",
    "* For loops allow us to repeat computations with different numbers.\n",
    "* A variable is a named place to store something.\n",
    "* Variable names should be composed of letters, digits, periods, and underscores.\n",
    "* An assignment statement creates a variable and stores a number or string in it.\n",
    "* Strings are sequences of characters enclosed in single quotes (') or double quotes (\").\n",
    "* R can do computations on numbers using arithmetic operators.\n",
    "* Functions produce a value from their argument(s).\n",
    "* R implements most mathematical functions that you would need to use.\n",
    "* R has many functions that are useful in computing statistical values.\n",
    "\n",
    "---\n",
    "\n",
    "## Review\n",
    "Below is a quiz to review the recently covered material. Quizzes are _not_ graded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "83c9265e-494a-41c7-a5de-c59b0c27850b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "151ab8c1caf24f1b96d2f9c561b424ac",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What is the purpose of a for loop?\\n', 'output_t…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66307b674b5245308792b6b251514614",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. What does the command \\x1b[31;1m\"\\\\n\"\\x1b[0m do?…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P8Q1, L3P8Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Key Terms<a class=\"anchor\" id=\"DS102L3_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59b31685-f692-40e7-927e-835c06a6464c",
   "metadata": {},
   "source": [
    "# Key Terms\n",
    "\n",
    "Below is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Variable</td>\n",
    "        <td>A place to store a piece of information. Must be named with A-Z, a-z, 0-9, underscore, or period.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Assignment</td>\n",
    "        <td>Putting a value in a variable. Done with <- , =, or -> . </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Environment Pane</td>\n",
    "        <td>Area of R Studio where you can see variables and data.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>String</td>\n",
    "        <td>Character data; denoted with single or double quotes.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Order of Operations</td>\n",
    "        <td>The order in which R computes arithmetic: Parentheses, Exponents, Multiplication, Division, Addition, Subtraction. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Vector</td>\n",
    "        <td>Ordered collection of numbers. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Element</td>\n",
    "        <td>One number in a vector. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>For Loop</td>\n",
    "        <td>An easy way to repeat a task over a series of data.  Takes the form \"for this in that, do something.\" </td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "---\n",
    "\n",
    "# Key Functions in R\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>paste()</td>\n",
    "        <td>Combines two strings together.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>sqrt()</td>\n",
    "        <td>Takes the square root of a number.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>pnorm()</td>\n",
    "        <td>Finds the percentile for a z score.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>function()</td>\n",
    "        <td>Makes a function.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>c()</td>\n",
    "        <td>Creates a vector of numbers listed in the parentheses. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>1:10</td>\n",
    "        <td>Makes a sequential vector, starting at the first number and incrementing by one to the last number. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>cat()</td>\n",
    "        <td>Concatenates (attaches) strings together. </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>\"\\n\"</td>\n",
    "        <td>Adds a line break. </td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Hands-On<a class=\"anchor\" id=\"DS102L3_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS102L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "729efa32-70b1-4b1f-a568-1c9718918942",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "For your Lesson 3 Hands-On, you will be solving the following word problem. This Hands-On **will** be graded, so be sure you complete all requirements. Please complete this Hands-On within an R script file and submit it below when completed. \n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may want to watch <a href=\"https://vimeo.com/408696478\">this recorded live workshop </a> before beginning the hands-on, which goes over a similar example.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "[DS102-L3-For-Loop-Handson-Helper](Examples/DS102-L3-For-Loop-Handson-Helper.ipynb)\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "Premier restaurants and bars are now serving drinks with ice spheres rather than ice cubes to chill the drink. Suppose you work for an ice vendor, and are tasked with measuring the size of manufactured ice spheres. Rather than measure the diameter directly, you weigh each sphere. You consulted with your company's ice scientist, and they gave you the following formula to convert the ice sphere's weight in grams to its diameter in inches (assuming it is weighed at 0 degrees Fahrenheit and is perfectly spherical); d is the sphere's diameter, and w is the sphere's weight.\n",
    "\n",
    "---\n",
    "![d equals two divided by two point five four open parentheses w divided by zero point nine two times four thirds times pi close parentheses to one third power.](Media/L03-Exam.png)\n",
    "\n",
    "---\n",
    "Create a function called ```diam()``` that computes the diameter of the sphere from its argument.\n",
    "Create a for loop that will use your ```diam()``` function to compute the diameters of spheres with the following weights in grams: 0.96, 1.51, 2.17, 3.85, 4.45, and 6.02.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire document when finished!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>To zip your file on <b>Windows</b>, right click on the file and select \"Send to\", then select \"Compressed (zipped) folder\". For <b>Mac</b> users, right click on the file and select \"Compress\", then select your file from the options.</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b831f73f-d039-45c2-8d3b-0fc8f61fff07",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}