Unit 6/Python-Bootcamp-Unit6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Python Bootcamp - Unit 6**\n",
    "---\n",
    "**Author:** David Dobolyi\n",
    "\n",
    "**Key Concepts**\n",
    "- [Control Flow](#Control-Flow)\n",
    "    - [if](#if)\n",
    "        - [elif, else](#elif,-else)\n",
    "        - [pass](#pass)\n",
    "        - [Nesting](#Nesting)\n",
    "        - [Input](#Input)\n",
    "    - [for](#for)\n",
    "        - [break](#break)\n",
    "        - [continue](#continue)\n",
    "        - [enumerated](#enumerated)\n",
    "        - [List Comprehension](#List-Comprehension)\n",
    "    - [while](#while)\n",
    "        - [break and continue](#break-and-continue)\n",
    "- [Defining Functions](#Defining-Functions)\n",
    "    - [lambda and map](#lambda-and-map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Control Flow\n",
    "\n",
    "Programming languages like Python shine when they are used to automate complex -- or repetitive -- tasks. To accomplish this, we now need to introduce a set of basic *control flow* keywords, which are designed to control how code is processed. These include:\n",
    "\n",
    "- **if**\n",
    "- **for**\n",
    "- **while**\n",
    "\n",
    "In the following sections, we will look at each of these using a set of basic examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if\n",
    "\n",
    "An *if* statement is used to set up and evaluate one or more conditions or rules that determine what needs to be done in a given situation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"if\" statement\n",
      "******************\n",
      "\n",
      "The \"if\" statement is used for conditional execution:\n",
      "\n",
      "   if_stmt ::= \"if\" assignment_expression \":\" suite\n",
      "               (\"elif\" assignment_expression \":\" suite)*\n",
      "               [\"else\" \":\" suite]\n",
      "\n",
      "It selects exactly one of the suites by evaluating the expressions one\n",
      "by one until one is found to be true (see section Boolean operations\n",
      "for the definition of true and false); then that suite is executed\n",
      "(and no other part of the \"if\" statement is executed or evaluated).\n",
      "If all expressions are false, the suite of the \"else\" clause, if\n",
      "present, is executed.\n",
      "\n",
      "Related help topics: TRUTHVALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('if')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, suppose we have a variable named `myValue` and we only want to display it if it contains an integer. As implied by our intention, we can use an *if* statement to set this up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "myValue = 3\n",
    "\n",
    "if type(myValue) == int:\n",
    "    display(myValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a couple of important things to note regarding this example.\n",
    "\n",
    "1. To use *if*, we must provide a valid expression to be tested that returns a `True` or `False` Boolean value (i.e., in this case, does `type(myValue) == int`). The *if* statement will execute the subsequent code if that expression is `True`.\n",
    "2. We must provide one or more commands to be executed if the *if* statement is found to be `True`, and these must be indented for Python to recognize the intent.\n",
    "\n",
    "Regarding the first point, notice what happens when `myValue` is not an `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "myValue = 'three'\n",
    "\n",
    "if type(myValue) == int:\n",
    "    display(myValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because `'three'` is not an `int` type (i.e., it's `str`), the subsequent `display(myValue)` code is not executed.\n",
    "\n",
    "As for the second point, note that we could have provided multiple instructions to execute in a `True` case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is an int!\n"
     ]
    }
   ],
   "source": [
    "myValue = 3\n",
    "\n",
    "if type(myValue) == int:\n",
    "    display(myValue)\n",
    "    print('The value is an int!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, note that any expression that returns a Boolean value could be used. For example, we could rewrite the code above to use the built-in **isinstance** function to test if our value is of a specified type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is an int!\n"
     ]
    }
   ],
   "source": [
    "myValue = 3\n",
    "\n",
    "if isinstance(myValue, int):\n",
    "    display(myValue)\n",
    "    print('The value is an int!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **elif, else**\n",
    "\n",
    "We can also provide additional tests besides *if* using the keywords *elif* (else if) and *else* that lead to different outcomes, as noted on the help output earlier. When combined, these various keywords can be used to form a heirarchical test akin to a *decision tree*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value 'hello' is a string!\n"
     ]
    }
   ],
   "source": [
    "myValue = 'hello'\n",
    "\n",
    "if type(myValue) == int:\n",
    "    display(myValue)\n",
    "    print('The value is an integer!')\n",
    "elif type(myValue) == str:\n",
    "    print('The value \\'' + myValue + '\\' is a string!')\n",
    "elif type(myValue) == bool or type(myValue) == float:\n",
    "    print('The value is not an integer.')\n",
    "else:\n",
    "    print('The value is something else:', type(myValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown in the example above, many tests can be strung together in this fashion, and the tests can themselves be complex (e.g., consisting of multiple conditions combined with *and* or *or*). Moreover, notice that the two keywords *elif* and *else* work similarly, although the former requires including a condition just like *if*, whereas the latter does not, since it's intended to be used as a catch-all for cases that don't match a specific rule, and as such, should be the last clause in the sequence.\n",
    "\n",
    "##### **pass**\n",
    "\n",
    "Occasionally, it can also be helpful or necessary to include a *pass* statement as part of a complex if-else sequence in cases where certain outcomes should be ignored:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "myValue = None\n",
    "\n",
    "if type(myValue) == int:\n",
    "    display(myValue)\n",
    "    print('The value is an integer!')\n",
    "elif type(myValue) == str:\n",
    "    print('The value \\'' + myValue + '\\' is a string!')\n",
    "elif type(myValue) == bool or type(myValue) == float:\n",
    "    print('The value is not an integer.')\n",
    "elif myValue is None:\n",
    "    pass\n",
    "else:\n",
    "    print('The value is something else:', type(myValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we do nothing in cases where `myValue` has no type (i.e., `None`): *pass* essentially serves to allow for a condition to be set up when no operation shown be performed for situations that are `True` (i.e., as mentioned earlier, it's necessary to supply *something* to be done after an *if*, *elif*, etc., but *pass* is functionally equivalent to supplying nothing). Occasionally, it can also be useful to use *pass* to intercept an error and simply ignore it (i.e., by doing nothing).\n",
    "\n",
    "##### **Nesting**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, note that there is nothing stopping you from nesting multiple *if* statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value -3 is a negative integer!\n"
     ]
    }
   ],
   "source": [
    "myValue = -3\n",
    "\n",
    "if type(myValue) == int:\n",
    "    if myValue > 0:\n",
    "        print('The value', str(myValue), 'is a positive integer!')\n",
    "    elif myValue < 0:\n",
    "        print('The value', str(myValue), 'is a negative integer!')\n",
    "    else:\n",
    "        print('The value is 0!')\n",
    "elif type(myValue) == str:\n",
    "    print('The value \\'' + myValue + '\\' is a string!')\n",
    "elif type(myValue) == bool or type(myValue) == float:\n",
    "    print('The value is not an integer.')\n",
    "elif myValue is None:\n",
    "    pass\n",
    "else:\n",
    "    print('The value is something else:', type(myValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **Input**\n",
    "\n",
    "While these examples have hopefully been elucidating, they are also rather simplistic. In practice, *if* statements are typically more useful when we are less sure about what value will be fed in for evaluation. For instance, to make this example more flexible, we can provide the user the option to input their own data using the *input* function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Provide a value: 'user input'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value 'user input' is a string!\n"
     ]
    }
   ],
   "source": [
    "myValue = eval(input(prompt = 'Provide a value:'))\n",
    "\n",
    "if type(myValue) == int:\n",
    "    if myValue > 0:\n",
    "        print('The value', str(myValue), 'is a positive integer!')\n",
    "    elif myValue < 0:\n",
    "        print('The value', str(myValue), 'is a negative integer!')\n",
    "    else:\n",
    "        print('The value is 0!')\n",
    "elif type(myValue) == str:\n",
    "    print('The value \\'' + myValue + '\\' is a string!')\n",
    "elif type(myValue) == bool or type(myValue) == float:\n",
    "    print('The value is not an integer.')\n",
    "elif myValue is None:\n",
    "    pass\n",
    "else:\n",
    "    print('The value is something else:', type(myValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for\n",
    "\n",
    "In Python, the *for* statement is used to create a *loop* that iterates commands over a sequence (e.g., a list):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"for\" statement\n",
      "*******************\n",
      "\n",
      "The \"for\" statement is used to iterate over the elements of a sequence\n",
      "(such as a string, tuple or list) or other iterable object:\n",
      "\n",
      "   for_stmt ::= \"for\" target_list \"in\" expression_list \":\" suite\n",
      "                [\"else\" \":\" suite]\n",
      "\n",
      "The expression list is evaluated once; it should yield an iterable\n",
      "object.  An iterator is created for the result of the\n",
      "\"expression_list\".  The suite is then executed once for each item\n",
      "provided by the iterator, in the order returned by the iterator.  Each\n",
      "item in turn is assigned to the target list using the standard rules\n",
      "for assignments (see Assignment statements), and then the suite is\n",
      "executed.  When the items are exhausted (which is immediately when the\n",
      "sequence is empty or an iterator raises a \"StopIteration\" exception),\n",
      "the suite in the \"else\" clause, if present, is executed, and the loop\n",
      "terminates.\n",
      "\n",
      "A \"break\" statement executed in the first suite terminates the loop\n",
      "without executing the \"else\" clause’s suite.  A \"continue\" statement\n",
      "executed in the first suite skips the rest of the suite and continues\n",
      "with the next item, or with the \"else\" clause if there is no next\n",
      "item.\n",
      "\n",
      "The for-loop makes assignments to the variables in the target list.\n",
      "This overwrites all previous assignments to those variables including\n",
      "those made in the suite of the for-loop:\n",
      "\n",
      "   for i in range(10):\n",
      "       print(i)\n",
      "       i = 5             # this will not affect the for-loop\n",
      "                         # because i will be overwritten with the next\n",
      "                         # index in the range\n",
      "\n",
      "Names in the target list are not deleted when the loop is finished,\n",
      "but if the sequence is empty, they will not have been assigned to at\n",
      "all by the loop.  Hint: the built-in function \"range()\" returns an\n",
      "iterator of integers suitable to emulate the effect of Pascal’s \"for i\n",
      ":= a to b do\"; e.g., \"list(range(3))\" returns the list \"[0, 1, 2]\".\n",
      "\n",
      "Note:\n",
      "\n",
      "  There is a subtlety when the sequence is being modified by the loop\n",
      "  (this can only occur for mutable sequences, e.g. lists).  An\n",
      "  internal counter is used to keep track of which item is used next,\n",
      "  and this is incremented on each iteration.  When this counter has\n",
      "  reached the length of the sequence the loop terminates.  This means\n",
      "  that if the suite deletes the current (or a previous) item from the\n",
      "  sequence, the next item will be skipped (since it gets the index of\n",
      "  the current item which has already been treated).  Likewise, if the\n",
      "  suite inserts an item in the sequence before the current item, the\n",
      "  current item will be treated again the next time through the loop.\n",
      "  This can lead to nasty bugs that can be avoided by making a\n",
      "  temporary copy using a slice of the whole sequence, e.g.,\n",
      "\n",
      "     for x in a[:]:\n",
      "         if x < 0: a.remove(x)\n",
      "\n",
      "Related help topics: break, continue, while\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('for')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see this via two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'two'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'four'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# show each value in myList\n",
    "for eachValue in myList:\n",
    "    display(eachValue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# show the type of each value in myList\n",
    "for eachValue in myList:\n",
    "    display(type(eachValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to *if* statements, Python requires *for* loops to be set up in a specific fashion, including indenting the expression(s) to be executed during each iteration. Multiple expressions can be applied during the *for* loop, and these can include things like nested *if* statements. For example, suppose we wanted to only display the integer values from `myList`; to accomplish this, we could write the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]\n",
    "\n",
    "for eachValue in myList:\n",
    "    if type(eachValue) == int:\n",
    "        display(eachValue)\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could further complicate this example by creating a new list from the original `myList` that only retains the integer values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]\n",
    "intList = []\n",
    "\n",
    "for eachValue in myList:\n",
    "    if type(eachValue) == int:\n",
    "        intList.append(eachValue)\n",
    "        \n",
    "intList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The possibilities are ultimately limitless, and *for* syntax can be very powerful for accomplishing a wide array of tasks.\n",
    "\n",
    "##### **break**\n",
    "\n",
    "If necessary, you can stop a loop early before iterating across the entirety of a sequence using a *break* statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "True\n",
      "Encountered a string value: 'this will cause a break'; stopping early...\n"
     ]
    }
   ],
   "source": [
    "myList = [3, 2, True, 'this will cause a break', False, 1, 2]\n",
    "\n",
    "# display values, but break on string data\n",
    "for eachValue in myList:\n",
    "    if type(eachValue) == str:\n",
    "        print('Encountered a string value: \\'{}\\'; stopping early...'.format(eachValue)) # using string formatting to insert a value (i.e., format method)\n",
    "        break\n",
    "    print(eachValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **continue**\n",
    "\n",
    "Alternatively, the *continue* statement can be useful for skipping a particular loop iteration. For instance, while *break* resulted in the iteration ending upon encountering a string value in the earlier example, in this one, we will simply pass over it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "True\n",
      "False\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "myList = [3, 2, True, 'this will be skipped', False, 1, 2]\n",
    "\n",
    "# display values, but break on string data\n",
    "for eachValue in myList:\n",
    "    if type(eachValue) == str:\n",
    "        continue # end the iteration here immediately and move on to the next one\n",
    "    print(eachValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **enumerated**\n",
    "\n",
    "In certain situations, it may be useful to track the index value while looping through values. To accomplish this, you can use the *enumerated* function. For instance, to find the indexes for each integer value in a list, you could do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an integer at index 0: 1\n",
      "Found an integer at index 2: 3\n",
      "Found an integer at index 4: 5\n"
     ]
    }
   ],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]\n",
    "\n",
    "for i, eachValue in enumerate(myList):\n",
    "    if type(eachValue) == int:\n",
    "        print('Found an integer at index ', i, ': ', eachValue, sep = '')\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### **List Comprehension**\n",
    "\n",
    "Python allows for a special use-case for *for* when working with lists to write code that's more readable than writing out a full-on *for* loop. For instance, consider we wanted to create a list of the types of variables in `myList`. Using code from earlier, we may have written this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[int, str, int, str, int]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]\n",
    "myTypes = []\n",
    "\n",
    "for eachValue in myList:\n",
    "    myTypes.append(type(eachValue))\n",
    "        \n",
    "myTypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we could have written this more concisely as follows using *list comprehension*, which is useful when we are trying to define a list as a result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[int, str, int, str, int]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList = [1, 'two', 3, 'four', 5]\n",
    "\n",
    "[type(i) for i in myList]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehension is also useful for working with lists in a similar fashion to NumPy arrays. For instance, we can square each value in a list of numbers as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 20.25, 25]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNumbers = [3, 4.5, 5]\n",
    "\n",
    "[i ** 2 for i in myNumbers]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you could have casted to NumPy (although this requires a package import):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9.  , 20.25, 25.  ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "myNumbersArr = np.array(myNumbers)\n",
    "\n",
    "myNumbersArr ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### while\n",
    "\n",
    "In addition to *for* loops, which iterate across a sequence, Python provides *while* to loop commands based on a condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"while\" statement\n",
      "*********************\n",
      "\n",
      "The \"while\" statement is used for repeated execution as long as an\n",
      "expression is true:\n",
      "\n",
      "   while_stmt ::= \"while\" assignment_expression \":\" suite\n",
      "                  [\"else\" \":\" suite]\n",
      "\n",
      "This repeatedly tests the expression and, if it is true, executes the\n",
      "first suite; if the expression is false (which may be the first time\n",
      "it is tested) the suite of the \"else\" clause, if present, is executed\n",
      "and the loop terminates.\n",
      "\n",
      "A \"break\" statement executed in the first suite terminates the loop\n",
      "without executing the \"else\" clause’s suite.  A \"continue\" statement\n",
      "executed in the first suite skips the rest of the suite and goes back\n",
      "to testing the expression.\n",
      "\n",
      "Related help topics: break, continue, if, TRUTHVALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('while')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As noted in the documentation, a *while* loop will continue to run as long as the expression being tested returns `True`. As soon as the expression becomes `False`, the looping will stop (although keep in mind this does mean it's possible to create loops that unintentionally loop forever, so be careful). The following is a basic example of a *while* loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop Iteration: 1\n",
      "Loop Iteration: 2\n",
      "Loop Iteration: 3\n",
      "Loop Iteration: 4\n",
      "Loop Iteration: 5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "\n",
    "while i <= 5:\n",
    "    print('Loop Iteration:', i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the condition is evaluated prior to the first iteration of the loop, it's important to keep in mind that any variables used within the condition must be defined beforehand.\n",
    "\n",
    "In general, the use of *while* loops is less common in data science and more common for programming repetitive or timed tasks.\n",
    "\n",
    "##### **break and continue**\n",
    "\n",
    "Similar to *for* loops, while loops also support using both *break* and *continue* statements. The former is used to stop the *while* loop early, typically based on a condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop Iteration: 1\n",
      "Loop Iteration: 2\n",
      "Loop Iteration: 3\n",
      "3/3 = 0; breaking loop...\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "\n",
    "while i <= 5:\n",
    "    print('Loop Iteration:', i)\n",
    "    \n",
    "    if i % 3 == 0:\n",
    "        print('{}/3 = 0; breaking loop...'.format(i))\n",
    "        break\n",
    "    \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By contrast, the latter is used to skip an iteration through the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop Iteration: 1\n",
      "Loop Iteration: 2\n",
      "3/3 = 0; continuing loop...\n",
      "Loop Iteration: 4\n",
      "Loop Iteration: 5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "\n",
    "while i <= 5:\n",
    "    \n",
    "    if i % 3 == 0:\n",
    "        print('{}/3 = 0; continuing loop...'.format(i))\n",
    "        i += 1\n",
    "        continue\n",
    "    \n",
    "    print('Loop Iteration:', i)  \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Defining Functions\n",
    "\n",
    "Throughout this bootcamp, we have introduced a wide range of built-in and imported functions. As you work more with Python, you may find it useful to be able to define your own, user-defined functions, and this can be done easily use the *def* keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Function definitions\n",
      "********************\n",
      "\n",
      "A function definition defines a user-defined function object (see\n",
      "section The standard type hierarchy):\n",
      "\n",
      "   funcdef                   ::= [decorators] \"def\" funcname \"(\" [parameter_list] \")\"\n",
      "               [\"->\" expression] \":\" suite\n",
      "   decorators                ::= decorator+\n",
      "   decorator                 ::= \"@\" assignment_expression NEWLINE\n",
      "   parameter_list            ::= defparameter (\",\" defparameter)* \",\" \"/\" [\",\" [parameter_list_no_posonly]]\n",
      "                        | parameter_list_no_posonly\n",
      "   parameter_list_no_posonly ::= defparameter (\",\" defparameter)* [\",\" [parameter_list_starargs]]\n",
      "                                 | parameter_list_starargs\n",
      "   parameter_list_starargs   ::= \"*\" [parameter] (\",\" defparameter)* [\",\" [\"**\" parameter [\",\"]]]\n",
      "                               | \"**\" parameter [\",\"]\n",
      "   parameter                 ::= identifier [\":\" expression]\n",
      "   defparameter              ::= parameter [\"=\" expression]\n",
      "   funcname                  ::= identifier\n",
      "\n",
      "A function definition is an executable statement.  Its execution binds\n",
      "the function name in the current local namespace to a function object\n",
      "(a wrapper around the executable code for the function).  This\n",
      "function object contains a reference to the current global namespace\n",
      "as the global namespace to be used when the function is called.\n",
      "\n",
      "The function definition does not execute the function body; this gets\n",
      "executed only when the function is called. [2]\n",
      "\n",
      "A function definition may be wrapped by one or more *decorator*\n",
      "expressions. Decorator expressions are evaluated when the function is\n",
      "defined, in the scope that contains the function definition.  The\n",
      "result must be a callable, which is invoked with the function object\n",
      "as the only argument. The returned value is bound to the function name\n",
      "instead of the function object.  Multiple decorators are applied in\n",
      "nested fashion. For example, the following code\n",
      "\n",
      "   @f1(arg)\n",
      "   @f2\n",
      "   def func(): pass\n",
      "\n",
      "is roughly equivalent to\n",
      "\n",
      "   def func(): pass\n",
      "   func = f1(arg)(f2(func))\n",
      "\n",
      "except that the original function is not temporarily bound to the name\n",
      "\"func\".\n",
      "\n",
      "Changed in version 3.9: Functions may be decorated with any valid\n",
      "\"assignment_expression\". Previously, the grammar was much more\n",
      "restrictive; see **PEP 614** for details.\n",
      "\n",
      "When one or more *parameters* have the form *parameter* \"=\"\n",
      "*expression*, the function is said to have “default parameter values.”\n",
      "For a parameter with a default value, the corresponding *argument* may\n",
      "be omitted from a call, in which case the parameter’s default value is\n",
      "substituted.  If a parameter has a default value, all following\n",
      "parameters up until the “\"*\"” must also have a default value — this is\n",
      "a syntactic restriction that is not expressed by the grammar.\n",
      "\n",
      "**Default parameter values are evaluated from left to right when the\n",
      "function definition is executed.** This means that the expression is\n",
      "evaluated once, when the function is defined, and that the same “pre-\n",
      "computed” value is used for each call.  This is especially important\n",
      "to understand when a default parameter is a mutable object, such as a\n",
      "list or a dictionary: if the function modifies the object (e.g. by\n",
      "appending an item to a list), the default value is in effect modified.\n",
      "This is generally not what was intended.  A way around this is to use\n",
      "\"None\" as the default, and explicitly test for it in the body of the\n",
      "function, e.g.:\n",
      "\n",
      "   def whats_on_the_telly(penguin=None):\n",
      "       if penguin is None:\n",
      "           penguin = []\n",
      "       penguin.append(\"property of the zoo\")\n",
      "       return penguin\n",
      "\n",
      "Function call semantics are described in more detail in section Calls.\n",
      "A function call always assigns values to all parameters mentioned in\n",
      "the parameter list, either from positional arguments, from keyword\n",
      "arguments, or from default values.  If the form “\"*identifier\"” is\n",
      "present, it is initialized to a tuple receiving any excess positional\n",
      "parameters, defaulting to the empty tuple. If the form\n",
      "“\"**identifier\"” is present, it is initialized to a new ordered\n",
      "mapping receiving any excess keyword arguments, defaulting to a new\n",
      "empty mapping of the same type.  Parameters after “\"*\"” or\n",
      "“\"*identifier\"” are keyword-only parameters and may only be passed by\n",
      "keyword arguments.  Parameters before “\"/\"” are positional-only\n",
      "parameters and may only be passed by positional arguments.\n",
      "\n",
      "Changed in version 3.8: The \"/\" function parameter syntax may be used\n",
      "to indicate positional-only parameters. See **PEP 570** for details.\n",
      "\n",
      "Parameters may have an *annotation* of the form “\": expression\"”\n",
      "following the parameter name.  Any parameter may have an annotation,\n",
      "even those of the form \"*identifier\" or \"**identifier\".  Functions may\n",
      "have “return” annotation of the form “\"-> expression\"” after the\n",
      "parameter list.  These annotations can be any valid Python expression.\n",
      "The presence of annotations does not change the semantics of a\n",
      "function.  The annotation values are available as values of a\n",
      "dictionary keyed by the parameters’ names in the \"__annotations__\"\n",
      "attribute of the function object.  If the \"annotations\" import from\n",
      "\"__future__\" is used, annotations are preserved as strings at runtime\n",
      "which enables postponed evaluation.  Otherwise, they are evaluated\n",
      "when the function definition is executed.  In this case annotations\n",
      "may be evaluated in a different order than they appear in the source\n",
      "code.\n",
      "\n",
      "It is also possible to create anonymous functions (functions not bound\n",
      "to a name), for immediate use in expressions.  This uses lambda\n",
      "expressions, described in section Lambdas.  Note that the lambda\n",
      "expression is merely a shorthand for a simplified function definition;\n",
      "a function defined in a “\"def\"” statement can be passed around or\n",
      "assigned to another name just like a function defined by a lambda\n",
      "expression.  The “\"def\"” form is actually more powerful since it\n",
      "allows the execution of multiple statements and annotations.\n",
      "\n",
      "**Programmer’s note:** Functions are first-class objects.  A “\"def\"”\n",
      "statement executed inside a function definition defines a local\n",
      "function that can be returned or passed around.  Free variables used\n",
      "in the nested function can access the local variables of the function\n",
      "containing the def.  See section Naming and binding for details.\n",
      "\n",
      "See also:\n",
      "\n",
      "  **PEP 3107** - Function Annotations\n",
      "     The original specification for function annotations.\n",
      "\n",
      "  **PEP 484** - Type Hints\n",
      "     Definition of a standard meaning for annotations: type hints.\n",
      "\n",
      "  **PEP 526** - Syntax for Variable Annotations\n",
      "     Ability to type hint variable declarations, including class\n",
      "     variables and instance variables\n",
      "\n",
      "  **PEP 563** - Postponed Evaluation of Annotations\n",
      "     Support for forward references within annotations by preserving\n",
      "     annotations in a string form at runtime instead of eager\n",
      "     evaluation.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('def')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The actually process of writing functions begins to blur the line between introductory bootcamp material and more advanced uses (e.g., with other concepts falling into the latter camp including things like [*classes*](https://docs.python.org/3/tutorial/classes.html), which are used to define custom object structures).\n",
    "\n",
    "Nevertheless, writing a basic function is relatively straightforward, involving the following steps:\n",
    "\n",
    "1. Give it a name\n",
    "2. Set up its argument(s)\n",
    "3. Write indented code that gives it purpose\n",
    "4. Have it return one or more values (if necessary)\n",
    "\n",
    "For example, suppose we wanted to write a function to square a value since we weren't aware of the `**` operator. We could do this like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SquareValue (x):\n",
    "    return(x * x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this code, we have defined the function named <font color = 'blue'>*SquareValue*</font>, which takes a single argument named *x* that has no default value. To use the function, we simply call it and provide a value for the *x* argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SquareValue(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, functions will typically be more complicated, and will often take multiple arguments. For instance, suppose we wanted to write a wrapper function to give the existing *math.sqrt* function a built-in rounding capability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def RoundedSqrt (x, digits = 3):\n",
    "    res = math.sqrt(x)\n",
    "    res = round(res, ndigits = digits)\n",
    "    return(res) # note this all could have been done on a single line, i.e., return(round(math.sqrt(x), round))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the second argument (i.e., *round*) in <font color = 'blue'>*RoundedSqrt*</font> was initialized with a value, we don't necesarilly need to provide two arguments to use this function since it will assume the default value (i.e., `3`) unless told otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.732"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RoundedSqrt(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, our new function provides a rounded version of the *math* version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that given the addition *digits* argument, we can customize the degree of rounding of our new function by providing additional arguments to the call, just like we can for any other function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.73"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RoundedSqrt(3, digits = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, this is intended to be only a quick introduction to writing functions, whereas Python provides significantly more functionality that can be leveraged (e.g., see *keyword arguments* in the official Python 3 [tutorial](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)).\n",
    "\n",
    "##### **lambda and map**\n",
    "\n",
    "Besides *def*, Python provides the *lambda* keyword to define simple, short-term function equivalents for cases where its convenient. To create a basic *lambda expression*, use the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.73"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RoundedSqrtLambda = lambda x, digits: round(math.sqrt(x), digits)\n",
    "\n",
    "RoundedSqrtLambda(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we are storing our lambda function into a variable named *RoundedSqrtLambda*, and setting it up to take two arguments (i.e., *x* and *digits*) and produce the rounded sqrt of the *x* supplied x value.\n",
    "\n",
    "In practice, lambda functions are typically not named, since they are intended to be used only temporarily: a situation known as an *anonymous* (unnamed) function. For example, using the *map* function, which is designed to apply a set of values against a simple function, we can accomplish a lot with very little code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.73, 2.0, 2.24]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: round(x ** (1/2), 2), [3, 4, 5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are applying a bit of basic arithmetic (i.e., a number to the 1/2 power is equivalent to the square root) and some rounding in the form of a *lambda* function, and then using *map* to apply this *lambda* to each individual value in a list of values (i.e., `[3, 4, 5]`). Finally, we cast the result as a list to get the output in the desired form.\n",
    "\n",
    "Again, this is something we could have done in a more complex fashion involving a function and some other form of iteration, but *lambda* functions and *map* can provide a convienent short-hand in specific cases."
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}