Module1-PreliminaryPython/M1B_Python_Loops_and_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wZiTtZlHRbd_"
   },
   "source": [
    "Intro to Python: Loops, Ranges, Functions, Lambdas\n",
    "<html>\n",
    "    <summary></summary>\n",
    "    <p float=\"left\">\n",
    "         <div> <p></p> </div>\n",
    "         <div style=\"font-size: 20px; width: 600px;\">\n",
    "              <h1>\n",
    "               <left>Intro to Python: Loops, Ranges, Functions, Lambdas </left>\n",
    "              </h1>\n",
    "              <p><left>============================================================================</left> </p>              \n",
    "             <pre>Course: BIOM 421, Spring 2024\n",
    "Instructor: Dr. Brian Munsky\n",
    "Contact Info: munsky@colostate.edu\n",
    "Authors: Will Raymond, Dr. Luis Aguilera, Dr. Brian Munsky\n",
    "</pre>\n",
    "         </div>\n",
    "    </p>\n",
    "\n",
    "</html>\n",
    "\n",
    "<details>\n",
    "  <summary>Copyright info</summary>\n",
    "\n",
    "```\n",
    "Copyright 2023 Brian Munsky\n",
    "\n",
    "Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n",
    "\n",
    "1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n",
    "\n",
    "2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n",
    "\n",
    "3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n",
    "\n",
    "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n",
    "```\n",
    "<details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B2wNtrCqRmx2"
   },
   "source": [
    "In this notebook, we will introduce the basic logic syntax for Python, as well as how to write your own functions that do some arbitrary block of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4S1pJTVJ-WB9"
   },
   "source": [
    "# 1. Logic and Loops\n",
    "\n",
    "```Reading: Kinder, Nelson Section 3```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xMxDzuriVohE"
   },
   "source": [
    "## 1.A. For Loops\n",
    "\n",
    "A for loop loops over values in any given iterable object, whether it's a range(), list, or dictionary. Python uses indentations to define its code blocks, meaning you must indent the code to run in the for loop. Everything at the same indentation level is in one \"code block.\"\n",
    "\n",
    "The syntax to define a for loop is \"for item in iterable:\"\n",
    "\n",
    "``` python\n",
    "for value in iterable:\n",
    "  #Inside the loop\n",
    "  print(value)\n",
    "\n",
    "#outside the loop\n",
    "print(value)\n",
    "\n",
    "```\n",
    "\n",
    "If you are iterating over an unordered iterable object (such as a dictionary or set), note that it is not a set order and different instances of python may handle the ordering differently. Additionally when using ``` for x in dictionary```, Python will iterate over keys, not values. To iterate over values use ``` for x in dictionary.values()```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rusjOADxyDdg",
    "outputId": "7d72d3e9-bdde-4992-d562-998ceee5e5b9"
   },
   "outputs": [],
   "source": [
    "# Example for loop!\n",
    "\n",
    "for i in range (0,5):  # for i iterating from 0 to 4, list(range(0,4)) = [0,1,2,3,4]\n",
    "  print('im in the loop!')\n",
    "  print(i)\n",
    "print('im outside the loop')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zkKNIypFVq6D",
    "outputId": "fc0cc14a-d788-4bee-852e-2e78609aae0f"
   },
   "outputs": [],
   "source": [
    "example_iterables = {\"list\": [1,2,3],  # a list\n",
    "                     \"tuple\": (1,2,3), # a tuple\n",
    "                     \"range\": range(1,4), # a range object\n",
    "                     \"dict\": {'a':1,'b':2,'c':3}, # a dictionary\n",
    "                     \"dict.values()\":{'a':1,'b':2,'c':3}.values() # only a dictionaries values\n",
    "                     }\n",
    "\n",
    "# Change the next line to iterate over different iterables.\n",
    "iterable = \"dict.values()\" #@param [\"list\",\"tuple\",\"range\",\"dict\",\"dict.values()\"] {allow-input: true}\n",
    "print('iterating over a %s'%iterable)\n",
    "for x in example_iterables[iterable]:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QaJskRDXCIvN"
   },
   "source": [
    "There also some special logic commands that are used inside loops:\n",
    "\n",
    "```pass```, ```continue```, and ```break```.\n",
    "\n",
    "```pass``` code just keeps going (pass doesn't do anything, but is sometime useful when a command is required).\n",
    "\n",
    "```python\n",
    "if var == 1:\n",
    "  print('I will print')\n",
    "  pass\n",
    "  print('I wont print')\n",
    "\n",
    "```\n",
    "```continue``` will not run anything in that particular iteration of a loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xDYq2xGWCU91",
    "outputId": "a6a1fa16-0bd0-43e2-f160-dd7b29b1b493"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  if i == 5:\n",
    "    continue\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t58YcRUGDEJw"
   },
   "source": [
    "```break``` will end a given loop entirely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NB0yyDugDIzs",
    "outputId": "6066dcc0-2bbb-48a3-e308-50876fcc1ee3"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  if i == 5:\n",
    "    break\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KL99T5FBVttq"
   },
   "source": [
    "## 1.B. While Loops\n",
    "\n",
    "While loops will run a section of code until a particular condition is met or the statement ```break``` is reached. As with For loops, you must indent the code inside for a new code block. However, be sure you give a way for the loop to break! Otherwise it will never end until manually killed by a user (Ctrl-C / Command-C)\n",
    "\n",
    "Acceptable:\n",
    "\n",
    "```python\n",
    "x = 0\n",
    "while x < 50:\n",
    "  x+=1\n",
    "```\n",
    "\n",
    "Unacceptable -- will never end:\n",
    "```python\n",
    "while x == 0:\n",
    "  x=0\n",
    "```\n",
    "\n",
    "Acceptable -- will break once a particular value is reached:\n",
    "\n",
    "\n",
    "```python\n",
    "import numpy as np   #import numpy so we can draw some random numbers\n",
    "\n",
    "desired_number = 23\n",
    "total_draws = 0\n",
    "while True: #this loop will run forever\n",
    "  x = np.random.randint(0,50) # draw a random number 0 - 49\n",
    "  total_draws += 1  #count how many numbers we drew\n",
    "  if x == desired_number:  #if the random number is the desired number, break the while loop\n",
    "    break   \n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "w8_EJrpVVv66",
    "outputId": "c459853b-f7f7-483f-a5d5-e53af3378041"
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "print('x = %i before loop'%x)\n",
    "\n",
    "while x < 50:\n",
    "  x+=1\n",
    "print('x = %i after loop'%x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-2qUU10zVwB_",
    "outputId": "177cc9d2-cb87-47a7-ed33-cc961fe708c8"
   },
   "outputs": [],
   "source": [
    "## Here's a short code that will draw random numbers until a desired number is reached using a while loop\n",
    "\n",
    "import numpy as np   #import numpy so we can draw some random numbers\n",
    "import time\n",
    "\n",
    "starting_time = time.time() #let's time how long this loop takes\n",
    "\n",
    "desired_number = 23\n",
    "total_draws = 0\n",
    "\n",
    "#beginning of the while loop, remember the code inside\n",
    "# the indentation is the code block in the while statement\n",
    "\n",
    "while True: #this loop will run forever\n",
    "  max_number = 993  #@param {type:\"slider\", min:0, max:1500, step:1}\n",
    "  x = np.random.randint(0,max_number) # draw a random number 0 - 49\n",
    "  total_draws += 1  #count how many numbers we drew\n",
    "  if x == desired_number:  #if the random number is the desired number, break the while loop\n",
    "    break   #end the while loop!\n",
    "\n",
    "\n",
    "execution_time = time.time()-starting_time\n",
    "print('Total draws til getting a %i: %i'%(desired_number,total_draws))\n",
    "print('Execution time of the loop %f seconds'%(execution_time))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AAF08LKVVwq_"
   },
   "source": [
    "## 1.C. Logic Statements\n",
    "\n",
    "Logical statements are also crucial to coding!\n",
    "\n",
    "\n",
    "| Operator    | Description | Example  | Result\n",
    "| ----------- | ----------- | ------------ | --------- |\n",
    "| ==      |  equal to   | ```1 == 1``` | ```True``` |\n",
    "| != | not equal to |   ```1 != 1``` | ```False``` |\n",
    "| >=   |  greater than or equal to   |    ```5 >= 1 ``` | ```True``` |\n",
    "| <= | less than or equal to |    ```1 <= 1 ``` | ```True``` |\n",
    "| > | greater than | ```1 > 3``` | ```False``` |\n",
    "| < | less than | ```1 < 3``` | ```True``` |\n",
    "\n",
    "\n",
    "\n",
    "| Operator    | Description | Example | Result\n",
    "| ----------- | ----------- | ------------ | ---------- |\n",
    "| and   |  multiple statements are true, return true | ```1==1 and 2==1 ```   | ```False``` |\n",
    "| or | one of multiple statements is true, return true |```1==1 or 2==1 ```   | ```True``` |\n",
    "| not   |  the opposite of a statement | ```not(1==1) ```    |  ```False``` |\n",
    "| is | are the objects the same? | ```int(1) is int(1)```  |  ```True``` |\n",
    "| is not | are the objects different?  | ```int(1) is not float(1)```|  ```True``` |\n",
    "| in | is an object in an iterable?  | ```'a' in ['a','b','c]``` |  ```True``` |\n",
    "| not in | is an object not in an iterable? |```'f' not in ['a','b','c]```  |  ```True``` |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "md3miyISFfzX"
   },
   "source": [
    "### If Statements\n",
    "\n",
    "If statements run the code block if the logical condition they are handed is true.\n",
    "\n",
    "```\n",
    "x = 0\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "\n",
    "if x == 0:\n",
    "  print('x equals 0')\n",
    "\n",
    "```\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ROph8iU_FvrX",
    "outputId": "7326dc87-ecfb-4486-d1f2-3381c43f6012"
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "\n",
    "if x == 0:\n",
    "  print('x equals 0')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dt-L0vDpTAIi"
   },
   "source": [
    "Additionally you can do multiple conditions with ```elif``` and ```else```\n",
    "\n",
    "In this example, the if else handles the case where x == 1 and x == anything else\n",
    "\n",
    "```python\n",
    "x = 2\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "else:\n",
    "  print('x equals something other than 1)\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qtxg1fz4Fvyo",
    "outputId": "6ba544ef-cf15-473b-b9cf-86775ddfd197"
   },
   "outputs": [],
   "source": [
    "x = 2\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "else:\n",
    "  print('x equals something other than 1')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TvjVUVpPTOmB"
   },
   "source": [
    "### 'elif' statements.\n",
    "With an ```elif``` statement you can handle multiple conditions, and the condition where nothing meets the above conditions.\n",
    "\n",
    "```python\n",
    "x = 2\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "elif x==2:\n",
    "  print('x equals 2')\n",
    "elif x==3:\n",
    "  print('x equals 3')\n",
    "else:\n",
    "  print('x does not equal 1, 2, or 3')\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5qQ-KcvzTun3",
    "outputId": "b898323f-b114-431a-8d9c-8cd5f8eeb11b"
   },
   "outputs": [],
   "source": [
    "x = \"3\" # @param [1,2,3,4,5,6]\n",
    "x = int(x) #convert str dropdown to an integer\n",
    "if x == 1:\n",
    "  print('x equals 1')\n",
    "elif x==2:\n",
    "  print('x equals 2')\n",
    "elif x==3:\n",
    "  print('x equals 3')\n",
    "else:\n",
    "  print('x does not equal 1, 2, or 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Match/Case statements \n",
    "Match/Case statements provide an easy way to handle mutual exclusive options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"1\" \n",
    "#x = int(x) #convert str dropdown to an integer\n",
    "match x:\n",
    "    case 1|'1'|'one':\n",
    "          print('x equals 1')\n",
    "    case 2|'2':  \n",
    "        print('x equals 2')\n",
    "    case 3|'3':\n",
    "        print('x equals 3')\n",
    "    case _:\n",
    "      print('x does not equal 1, 2, or 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_ZJGoJehSdKd"
   },
   "source": [
    "Logical statements can also be strung together using various operators such as ```and```, or ```or```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gSKF_qoDScar",
    "outputId": "ef835779-97f8-4402-97c2-39c5567118fa"
   },
   "outputs": [],
   "source": [
    "x = 5 #@param {type:\"slider\", min:0, max:25, step:1}\n",
    "if x % 5 == 0 and x < 10 and x > 0:\n",
    "  print('X can only equal 5')\n",
    "else:\n",
    "  print('X does not equal 5')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EVnQ7eVUliZ2"
   },
   "source": [
    "### Combining Multiple logic statements\n",
    "\n",
    "\n",
    "| Operator    | Description | Example | Result\n",
    "| ----------- | ----------- | ------------ | ---------- |\n",
    "| and   |  multiple statements are true, return true | ```1==1 and 2==1 ```   | ```False``` |\n",
    "| or | one of multiple statements is true, return true |```1==1 or 2==1 ```   | ```True``` |\n",
    "\n",
    "Multiple logic statements can also be strung together for more complex statements using and, or or."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "U-C3LcnompPm",
    "outputId": "23240fdb-46de-4d2a-b8ae-f316a6c87b7b"
   },
   "outputs": [],
   "source": [
    "if 1 > 0 and 2 > 1:\n",
    "  print('This statement ran')\n",
    "\n",
    "if 1 < 0 or 2 > 1:\n",
    "  print('This statement also ran')\n",
    "\n",
    "if (1<0) | (2>1): # you can also use a bitwise or operator\n",
    "  print('This statement ran with a bitwise or')\n",
    "\n",
    "if (1<0) ^ (2>1): # you can also use a bitwise xor (exactly 1 must be true of the two statements)\n",
    "  print('This statement ran with a bitwise xor')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bj_xF5x5EmNP"
   },
   "source": [
    "## 1.D. Try / Except\n",
    "\n",
    "Python can also run codes that you expect to fail, however it will not tell you which exact line failed within a Try / Except statement!\n",
    "\n",
    "```python\n",
    "try:\n",
    "  3/0 # this will error\n",
    "except:\n",
    "  4/1 # this will not error\n",
    "\n",
    "```\n",
    "\n",
    "For a more in depth look at Exception handling, look at Pythons own documentation: https://docs.python.org/3/tutorial/errors.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "q0fajJt9E_2E",
    "outputId": "fcf44dc5-dd24-4626-aa15-ee7069e448e4"
   },
   "outputs": [],
   "source": [
    "variable = '1'\n",
    "try:\n",
    "  print(variable/3) # this will error, can't divide by a string\n",
    "except:\n",
    "  print('the try statement failed - now trying the other statement:')\n",
    "  print(int(variable)/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fHt0WskoV1En"
   },
   "source": [
    "##  1.E. range, enumerate, zip\n",
    "\n",
    "```range(start, stop, step)``` returns a range object containing an iterator of numbers start to stop in (integer) segments of step\n",
    "\n",
    "| Example  | Result\n",
    "| ------------ | --------- |\n",
    "| ```list(range(0,5))```   | ```[0,1,2,3,4,]```  |\n",
    "| ```list(range(5,0,-1))```   | ```[4,3,2,1,0]```  |\n",
    "| ```list(range(0,5,2))```   | ```[0,2,4]```  |\n",
    "\n",
    "```enumerate(iterable)``` is similar to iterating of the range of a length of an object, but enumerate gives a more readable form and returns out indexes of the iterable and the value of that index in the form of a tuple pair. For example converting the enumerate(list) would give you a list of tuples, with (index, list_value) as the entries in that list, take a glance:\n",
    "\n",
    "| Example  | Result\n",
    "| ------------ | --------- |\n",
    "| ```list(enumerate(['a','b','c']))```   | ```[(0, 'a'), (1, 'b'), (2, 'c')]```  |\n",
    "\n",
    "These three for loops are equivalent:\n",
    "```python\n",
    "tmp_list = ['a','b','c','d','e']\n",
    "for i in range(0,len(tmp_list)):  \n",
    "  print(tmp_list[i])\n",
    "```\n",
    "\n",
    "```python\n",
    "tmp_list = ['a','b','c','d','e']\n",
    "for ind,list_value in enumerate(tmp_list):\n",
    "  print(list_value)\n",
    "```\n",
    "\n",
    "```python\n",
    "tmp_inds = [0,1,2,3,4]\n",
    "tmp_list = ['a','b','c','d','e']\n",
    "for ind,list_value in zip(tmp_inds,tmp_list):\n",
    "  print(list_value)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u-Ujdbl_V8m4",
    "outputId": "8a958f97-276a-453a-df47-8677839fbb0b"
   },
   "outputs": [],
   "source": [
    "print('Example For loop with a range:')\n",
    "for i in range(0,5):\n",
    "  print(i)\n",
    "\n",
    "print('')\n",
    "print('Example For loop with an enumerate of a list:')\n",
    "tmp_list = ['a','b','c','d','e']\n",
    "for index,value in enumerate(tmp_list):\n",
    "  print(index, value)\n",
    "\n",
    "\n",
    "print('')\n",
    "print('Example For loop with an zipped list indexes and values:')\n",
    "tmp_inds = [0,1,2,3,4]\n",
    "tmp_list = ['a','b','c','d','e']\n",
    "for ind,list_value in zip(tmp_inds,tmp_list):\n",
    "  print(ind, list_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5XWsl1hmV8tr",
    "outputId": "d388e358-8fb8-48f2-ccad-85a06d5020a0"
   },
   "outputs": [],
   "source": [
    "list(enumerate(['a','b','c']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gzvM8NNIV843"
   },
   "source": [
    "## 1.F. List Comprehension\n",
    "\n",
    "List comprehension is a powerful method to process some of the looping logic in python without writing a full loop. For example these two statements in python are equivalent:\n",
    "\n",
    "```\n",
    "x = []\n",
    "for i in range(0,5):\n",
    "  x.append(i)\n",
    "```\n",
    "```\n",
    "[x for x in range(0,5)]\n",
    "```\n",
    "both return a list filled with values 0 to 4. How does this list comprehension syntax work and what can we do with it?\n",
    "\n",
    "The general syntax goes as follows:\n",
    "\n",
    "``` [ statement for item in iterable if logic condition ]```\n",
    "\n",
    "The statement can be anything, but is usually a function of the item being iterated over in the list comprehension.\n",
    "\n",
    "For a statement with a logical condition, its equivalent to putting an if statement with a for loop\n",
    "\n",
    "```\n",
    "x = []\n",
    "for i in range(0,10):\n",
    "  if x < 5:\n",
    "    x.append(i)\n",
    "```\n",
    "```\n",
    "[x for x in range(0,10) if x < 5]\n",
    "```\n",
    "\n",
    "Let's take a look at some examples:\n",
    "\n",
    "| Example    | Description | Result |\n",
    "| ----------- | ----------- | ------------ |\n",
    "| ```[int(x) for x in ['1','2','3']]```  |  for every item in the list of strings, convert it to an integer | ```[1,2,3] ```   |\n",
    "| ```[1 for x in ['1','2','3']]```  | would just return a 1 three times in a list since we don't change the statement in this instance |```[1,1,1]```\n",
    "| ```[int(x)==1 for x in ['1','2','3']]```  |  for every item in the list of strings, convert it to an integer, then return true if its equal to 1 | ```[True, False, False] ```   |\n",
    "| ```[int(x) for x in ['1','2','3'] if int(x) < 3]```  |  for every item in the list of strings, convert it to an integer, only keep it if its less than 3 | ```[1,2] ```   |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ynWDFP3DWA6R",
    "outputId": "e91d22e7-c692-4301-bfc5-ecfec5141150"
   },
   "outputs": [],
   "source": [
    "#  Example of getting the number of a set of characters in a string\n",
    "\n",
    "# our iterable, remember you can iterate over strings\n",
    "test_string = 'Hello I am a long string with lots of characters, Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor'\n",
    "# Let's use list comprehension to find out how many of a character set are in here\n",
    "character_set = ['e','a','i','o','u']\n",
    "\n",
    "matching_characters = [x.lower() for x in test_string if x.lower() in character_set]  # returns all matching characters\n",
    "character_values = [matching_characters.count(y) for y in character_set] # count the entries in the matching character list to get the values\n",
    "\n",
    "dict(zip(character_set, character_values ))  #turn it into a dictionary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vn3WA7_OWA8-",
    "outputId": "3dbb5618-7895-4de5-ba89-b5f1fa38efee"
   },
   "outputs": [],
   "source": [
    "#  Let's get the full counts of all unique characters in this string!!\n",
    "\n",
    "# our iterable, remember you can iterate over strings\n",
    "test_string = 'Hello I am a long string with lots of characters, Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor'\n",
    "\n",
    "character_set = list(set(list(test_string.lower()))) #all unique characters\n",
    "\n",
    "matching_characters = [x.lower() for x in test_string if x.lower() in character_set]  # returns all matching characters\n",
    "character_values = [matching_characters.count(y) for y in character_set] # count the entries in the matching character list to get the values\n",
    "\n",
    "dict(zip(character_set, character_values ))  #turn it into a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pcwqlZ-1-TyX"
   },
   "source": [
    "## Questions for self study (loops, logic, and list comprehension\n",
    "Try out these problems on your own.  Now may also be a good time to try problems 1-3 in the homework set # 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qhA-ra-WGo4Y"
   },
   "outputs": [],
   "source": [
    "## Write a for loop that runs backwards from 100 to 0 and print out every even number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Js-eeYGJ-U5u"
   },
   "outputs": [],
   "source": [
    "## Write a for loop that runs for 100 iterations and prints out a statement every 25 iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kmT_R6qtGdqQ"
   },
   "outputs": [],
   "source": [
    "## Write a loop that runs for 100 iterations and prints out the iteration number.\n",
    "## But for numbers divisible by 3 print out Fizz instead of the number,\n",
    "## and for numbers divisible by 5 print out Buzz instead of the number. For\n",
    "## numbers divisible by 3 and 5 print out \"FizzBuzz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KnzDZ2zOHap-"
   },
   "outputs": [],
   "source": [
    "## Write an if statement that only executes if all 4 of the following variables are even.\n",
    "a = 2\n",
    "b = 4\n",
    "c = a*b\n",
    "d = a*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "60J5PcmwGklI"
   },
   "outputs": [],
   "source": [
    "## Write a while loop that breaks when a counter gets to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lRchScW6GuY2"
   },
   "outputs": [],
   "source": [
    "## Given the following iterable object, use list comprehension to make a new dictionary\n",
    "## of the list keyed by a string named \"indexN\" where N is the index of the value\n",
    "## {index1 : first_obj, index2: second_obj, ...}\n",
    "\n",
    "new_list = ['Variable 1', 300, [3,3,3], 'ATCGATCG']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S_IpuWwhIZrA"
   },
   "source": [
    "Short Answer\n",
    "* What's the difference between a for loop and list comprehensions?\n",
    "* What are some issues with iterating over a dictionary's keys?\n",
    "* What's the command to get out of a while loop?\n",
    "* What's the difference between \"is\" operator and \"isinstance()\"?\n",
    "* What's the general formula for a list comprehension?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jpw91576-OaP"
   },
   "source": [
    "# 2. Functions\n",
    "\n",
    "```Reading: Kinder, Nelson Section 6.1 and Section 10```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ttPHCFS9WDUw"
   },
   "source": [
    "## 2.A. Function Definitions\n",
    "\n",
    "What if you don't want to copy paste a large chunk of code every time you need to execute it?\n",
    "\n",
    "Here's where **functions** come in. Say we want to use the previous sections code that gets the counts of all unique characters in a string repeatedly, we can define a Python function that we can call whenever we need it!\n",
    "\n",
    "\n",
    "```python\n",
    "def name(inputs, *args, **kwargs):\n",
    "  '''\n",
    "  doc string, documentation goes here\n",
    "  '''\n",
    "  code here\n",
    "  return result\n",
    "```\n",
    "\n",
    "Here we have introduced a couple new things, inputs, arguments (```*args```) and keyword arguments (```**kwargs```). Inputs are required inputs to the function otherwise python will return an error, Arguments are arbitrary inputs that have no keyword associated with them, and keyword arguments have a keyword associated with them. return denotes a variable to return from the function.\n",
    "\n",
    "```*``` denotes an unknown number of inputs, python will give these to the code in a tuple\n",
    "\n",
    "```**``` denotes an unknown number of named inputs that are provided to the code in a dictionary.\n",
    "\n",
    "So let's take our previous string to character counts result and turn it into a function!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "33ismCTPH6At"
   },
   "outputs": [],
   "source": [
    "def str_to_char_count_dict(string, ):\n",
    "  '''\n",
    "  This code takes a string and will return a dictionary of unique lowercase characters and their counts within the input string\n",
    "\n",
    "  Parameters\n",
    "  ----------\n",
    "  string : str\n",
    "    input string to convert\n",
    "\n",
    "  Returns\n",
    "  -------\n",
    "  char_dictionary : dict\n",
    "    a dictionary of character counts from a string\n",
    "  '''\n",
    "  character_set = list(set(list(string.lower()))) #all unique characters\n",
    "  matching_characters = [x.lower() for x in string if x.lower() in character_set]  # returns all matching characters\n",
    "  character_values = [matching_characters.count(y) for y in character_set] # count the entries in the matching character list to get the values\n",
    "\n",
    "  return dict(zip(character_set, character_values))  #turn it into a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-ey-rFuzWHcC",
    "outputId": "0bc27377-180f-4d1c-8e5b-369f912d9a89"
   },
   "outputs": [],
   "source": [
    "# let's use our new function!\n",
    "\n",
    "str_to_char_count_dict('new string!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hb68OcBoXWYE"
   },
   "source": [
    "How about what if we want more options for the user, with the same function?\n",
    "\n",
    "Here is where keyword arguments are useful as they allow you to set a default behavior for a function. Let's add the functionality to keep the case when converting our string in the function. We denote this by adding the named argument keep_case with its default behavior of false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zvOOXGXoWHg7"
   },
   "outputs": [],
   "source": [
    "def str_to_char_count_dict(string, keep_case=False):\n",
    "  '''\n",
    "  This code takes a string and will return a dictionary of unique lowercase characters and their counts within the input string\n",
    "  This docstring formatting is called a numpy docstring\n",
    "  https://numpydoc.readthedocs.io/en/latest/format.html\n",
    "\n",
    "  Parameters\n",
    "  ----------\n",
    "  string : str\n",
    "    input string to convert\n",
    "  keep_case: bool, default: False\n",
    "    keep the case of the string when converting\n",
    "\n",
    "  Returns\n",
    "  -------\n",
    "  char_dictionary : dict\n",
    "    a dictionary of character counts from a string\n",
    "  '''\n",
    "\n",
    "  if keep_case:\n",
    "    character_set = list(set(list(string))) #all unique characters (keep case)\n",
    "    matching_characters = [x for x in string if x in character_set]  # returns all matching characters doesn't convert case\n",
    "  else:\n",
    "    character_set = list(set(list(string.lower()))) #all unique characters\n",
    "    matching_characters = [x.lower() for x in string if x.lower() in character_set]  # returns all matching characters converts to lowercase\n",
    "  character_values = [matching_characters.count(y) for y in character_set] # count the entries in the matching character list to get the values\n",
    "\n",
    "  return dict(zip(character_set, character_values ))  #turn it into a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k9fJSuSzX7Vw",
    "outputId": "c8cd9dcd-1be0-417d-c68f-da61fd499e2d"
   },
   "outputs": [],
   "source": [
    "str_to_char_count_dict('NeW sTrInG!', keep_case=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pduOPRNzWHsi"
   },
   "source": [
    "## 2.B. Lambda functions\n",
    "\n",
    "What if we don't want to go through the full trouble of writing and defining a function and just want a simple object that does one command? Lambda is the tool for you. Lambda also allows you to redefine and create arbitrary functions programmatically!\n",
    "\n",
    "```obj = lambda *parameters: function```\n",
    "\n",
    "\n",
    "| Example    | Description | Result |\n",
    "| ----------- | ----------- | ------------ |\n",
    "| ``` squarer = lambda x: x**2``` |  provides a function that squares a single input | ```squarer(3) = 9 ```   |\n",
    "| ``` line = lambda x,m,b: m*x + b``` |  provides an y for the line given an x, m and b | ```line(3, 2, 5) = 11```   |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QkqJ3nw0WMji",
    "outputId": "378d9458-c6bc-4be9-92a1-797c45c95ce0"
   },
   "outputs": [],
   "source": [
    "squarer = lambda x: x**2\n",
    "\n",
    "print(squarer(3))\n",
    "print([squarer(x) for x in range(0,5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oBLZCknmWMmC",
    "outputId": "dbab069c-57d9-410e-8e74-895729866a84"
   },
   "outputs": [],
   "source": [
    "def power_generator(n):  # this function makes a function to the power of n\n",
    "   return lambda x: x**n\n",
    "\n",
    "power_functions = [power_generator(i) for i in range(0,5)]\n",
    "[pf(2) for pf in power_functions]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LPeOy1C0H7Et"
   },
   "source": [
    "## 2.C. Map routines\n",
    "\n",
    "Finally, a map is an easy way to pass an iterable to a function that only accepts limited inputs\n",
    "\n",
    "```python\n",
    "map(function_to_iterate, iterable)\n",
    "```\n",
    "Results must be pulled out by converting the map result to a list\n",
    "\n",
    "```python\n",
    "results = list(map_obj)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DaqDD8b1dA7n",
    "outputId": "8122036f-90e6-470c-ebfb-a10cd0004089"
   },
   "outputs": [],
   "source": [
    "squarer = lambda x: x**2\n",
    "map_obj = map(squarer, range(0,10))\n",
    "print(list(map_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OJjXHhU8OFye"
   },
   "source": [
    "### Generators\n",
    "\n",
    "Generators are useful when writing large iterators or handling memory intensive iterable objects. Technically, Generators are subsets of Iterators and are differentiated by having a ```yield``` statement inside their function definition, and are called by ```next```. **You can only iterate once over the generator object!!** For more indepth details you can read their documentation page:\n",
    "\n",
    "https://docs.python.org/3/howto/functional.html#generators\n",
    "\n",
    "The ```map``` function we just went over (as of Python 3.0+) returns an iterator object instead of a list, that is why we converted it to a list to print it out. But we could have just as easily done the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IKGLfa6vPdvD",
    "outputId": "a9db55e0-cef5-4d58-b493-8a867d4cda52"
   },
   "outputs": [],
   "source": [
    "squarer = lambda x: x**2\n",
    "map_obj = map(squarer, range(0,5))\n",
    "print(map_obj)\n",
    "\n",
    "# iterating over the generator object\n",
    "for i in map_obj:\n",
    "  print(i)\n",
    "\n",
    "# since we iterated over it already this will throw an error!\n",
    "# But if you comment out the previous loop you can run it unti it runs out of iterations:\n",
    "# print(next(map_obj))\n",
    "# print(next(map_obj))\n",
    "# print(next(map_obj))\n",
    "# print(next(map_obj))\n",
    "# print(next(map_obj))  \n",
    "# print(next(map_obj))  # this one will always thro an error \n",
    "\n",
    "print('using next')\n",
    "# im going to remake the generator and then use next to iterate over it\n",
    "map_obj = map(squarer, range(0,5))\n",
    "for i in range(5):\n",
    "  print(next(map_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mh8LsOuifVsQ"
   },
   "source": [
    "## Questions for self study (functions)\n",
    "Try these questions on your own.  You should also now be able to complete question 4 and 5 of Homework 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cH-gTM6eNgvn"
   },
   "outputs": [],
   "source": [
    "## Write a function definition that returns the decimal of a floating point number.\n",
    "## Write another version of this function as a lambda function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IrvPmPV7Id4r"
   },
   "outputs": [],
   "source": [
    "## Define a function that performs a moving average and takes a keyword argument\n",
    "## of \"window\" with its default set to 3. Use this window argument as the moving\n",
    "## average window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tAYtRf1oIeC_"
   },
   "outputs": [],
   "source": [
    "## Define a function with a single input that returns True if its input is a string called\n",
    "## is_string(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WCCyYderIeL1"
   },
   "outputs": [],
   "source": [
    "## Define a function that uses a dictionary to convert a given nucleotide sequence\n",
    "## to an amino acid sequence called \"nt2aa.\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pkfBuyYgIjHG"
   },
   "source": [
    "Short Answer\n",
    "* How do you convert a generator to a list?\n",
    "* How to you view a functions docstring?\n",
    "* What is the difference between a keyword argument and an argument?\n",
    "* Are inputs to a function required every time you run that function?"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}