01_c_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Course Announcements**\n",
    "- [Pre-Course Survey](https://forms.gle/5QuctoQEpCrad75F6) for EC, due Friday Oct 8\n",
    "    - Section 1 ==> EC\n",
    "    - Section 2 ==> Participation in the pedagogical experiment\n",
    "- **Datahub**: where discussion labs and assignments will be released\n",
    "- **Discussion Lab**: DOES NOT START UNTIL NEXT WEEK\n",
    "    - D1 will be posted Fri Oct 8, due Fri Oct 15\n",
    "- **Assignments**\n",
    "    - Practice Assignment, due Wed Oct 11   \n",
    "    - A1 will be posted Wed Oct 11, due Wed Oct 18\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/COGS108/Lectures-Fa23/blob/main/Week_01/01_02_python.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter & Python \n",
    " \n",
    "- Jupyter Notebooks\n",
    "- Python Review\n",
    "\n",
    "**Note**: This material is ~6 weeks of COGS 18...in a single lecture. It's intended to be a review."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Jupyter notebooks are a way to combine executable code, code outputs, and text into one connected file.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "The official documentation from project Jupyter is available \n",
    "<a href=\"https://jupyter-notebook.readthedocs.io/en/stable/\" class=\"alert-link\">here</a>\n",
    "and they also have some example notebooks \n",
    "<a href=\"https://github.com/jupyter/notebook/tree/master/docs/source/examples/Notebook\" class=\"alert-link\">here</a>\n",
    ".\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-danger\">\n",
    "If you need much more Python review than this notebook is giving, try <a href=\"https://www.codecademy.com/catalog/language/python\" class=\"alert-link\">Codecademy</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Menu Options & Shortcuts\n",
    "\n",
    "To get a quick tour of the Jupyter user-interface, click on the 'Help' menu, then click 'User Interface Tour'.\n",
    "\n",
    "There are also a large number of useful keyboard shortcuts. Click on the 'Help' menu, and then 'Keyboard Shortcuts' to see a list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "The main organizational structure of the notebook are <b> cells </b>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cells are an independent 'unit'. When you click into a cell, you can 'run' it by clicking Shift + Enter, or by pressing the play (Run) button above. \n",
    "\n",
    "Cells come in different types for writing different things - mainly, text or code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Markdown Cells\n",
    "\n",
    "Cells, can be markdown (text), like this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A brief note about Markdown. It's a way to specify all formatting within the text itself. \n",
    "\n",
    "For example, italicized text can be specified with an _underscore_ or *single asterisks*.\n",
    "\n",
    "Bold text requires __two underccores__ or **two asterisks**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Headers are specified with a pound sign\n",
    "\n",
    "## The more pound signs, the smaller the header\n",
    "\n",
    "#### But it's still larger\n",
    "\n",
    "than just plain text."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are also possible:\n",
    "    \n",
    "- item 1\n",
    "- item 2\n",
    "- item 3\n",
    "\n",
    "\n",
    "1. numbered item\n",
    "2. item 2\n",
    "3. item 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #1\n",
    "\n",
    "**What do you think three underscores around text will accomplish?**\n",
    "\n",
    "https://forms.gle/sXLu6m78hcDUKzFW6\n",
    "\n",
    "- A) bold\n",
    "- B) italicize\n",
    "- C) bold + italicize\n",
    "- D) normal text\n",
    "- E) I'm lost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___Use this cell to determine the answer to the question.___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #2\n",
    "\n",
    "https://forms.gle/tzH8MUP6FjoxX1Jn8\n",
    "\n",
    "**What would happen if I specified a numbered list but put the same number before each list item?**\n",
    "\n",
    "- A) the list would have the same number before each item\n",
    "- B) markdown would still format it with sequential numbers\n",
    "- C) markdown wouldn't know it was a list\n",
    "- D) normal text with everything on a single line\n",
    "- E) I'm lost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___Use this cell to determine the answer to the question.___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Cells\n",
    "\n",
    "Whenever you're writing code, you'll want to be sure the cell is set to be a code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell can also be code.\n",
    "a = 1\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cells can also have output, that gets printed out below the cell.\n",
    "c = a - b\n",
    "a\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you execute a cell with just a variable name in it, it will also get printed\n",
    "print(b)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running Cells\n",
    "\n",
    "- The numbers in the square brackets to the left of a cell show which cells have been run, and in what order.\n",
    "    - An asterisk (*) means that the cell is currently running\n",
    "    - You do not need to run cells in order! This is useful for flexibly testing and developing code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "For more useful information, check out Jupyter Notebooks \n",
    "<a href=\"https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/\" class=\"alert-link\">tips & tricks</a>\n",
    ", and more information on how \n",
    "<a href=\"http://jupyter.readthedocs.io/en/latest/architecture/how_jupyter_ipython_work.html\" class=\"alert-link\">notebooks work</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Review\n",
    "\n",
    "\n",
    "- variable assignment\n",
    "- variable types\n",
    "- operators\n",
    "- conditionals\n",
    "- loops\n",
    "- functions\n",
    "- namespaces and importing code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "In Python, variables are assigned with the general syntax <code>variable_name = value</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_variable = 1  # `my_variable` is a variable\n",
    "\n",
    "# This defines another variable\n",
    "other_var = 'variables are cool'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# once you create a variable it's stored in your namespace\n",
    "my_variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 29\n",
    "a = 'string'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://forms.gle/kWvX2vmM8f47obdr8\n",
    "\n",
    "**What is the value of `a`?**\n",
    "\n",
    "- A) 29\n",
    "- B) 'string'\n",
    "- C) '29'\n",
    "- D) 29 + 'string' \n",
    "- E) nothing or something else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use this cell to determine the answer to the question.\n",
    "# NOTE: the # at the beginning of a code cell line marks this as comment line\n",
    "# everything after it is just text for the human eye, it is not executed as code\n",
    "# but something on the next line, without the starting # is code, and will be executed\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reminder: Code Variables != Math Variables\n",
    "\n",
    "In mathematics: `=` refers to equality (as a statement of truth).\n",
    "\n",
    "In coding: `=` refers to assignment. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Math: What is x?\n",
    "\n",
    "$y = 10x + 2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code: What is x?\n",
    "\n",
    "`x = x + 1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reserved Words\n",
    "\n",
    "There are 33 words that are not allowed to be used for variable assignment in Python >3.6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table type=\"text/css\">\n",
    "  <tr>\n",
    "      <td><code>False</code></td>\n",
    "      <td><code>None</code></td>\n",
    "      <td><code>True</code></td>\n",
    "      <td><code>and</code></td>\n",
    "      <td><code>as</code></td>\n",
    "      <td><code>assert</code></td>\n",
    "      <td><code>break</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>class</code></td>\n",
    "      <td><code>continue</code></td>\n",
    "      <td><code>def</code></td>\n",
    "      <td><code>del</code></td>\n",
    "      <td><code>elif</code></td>\n",
    "      <td><code>else</code></td>\n",
    "      <td><code>except</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>finally</code></td>\n",
    "      <td><code>for</code></td>\n",
    "      <td><code>from</code></td>\n",
    "      <td><code>global</code></td>\n",
    "      <td><code>if</code></td>\n",
    "      <td><code>import</code></td>\n",
    "      <td><code>in</code></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "      <td><code>is</code></td>\n",
    "      <td><code>lambda</code></td>\n",
    "      <td><code>nonlocal</code></td>\n",
    "      <td><code>not</code></td>\n",
    "      <td><code>or</code></td>\n",
    "      <td><code>pass</code></td>\n",
    "      <td><code>raise</code></td>\n",
    "  </tr>    \n",
    "  <tr>\n",
    "      <td><code>return</code></td>\n",
    "      <td><code>try</code></td>\n",
    "      <td><code>while</code></td>\n",
    "      <td><code>with</code></td>\n",
    "      <td><code>yield</code></td>\n",
    "  </tr>    \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Assigment Cheat Sheet\n",
    "\n",
    "- Names are always on the left of the `=`, values are always on the right\n",
    "- Names are case sensitive\n",
    "- Variables cannot *start* with numbers or special characters\n",
    "- Python doesn't care what you name your variables\n",
    "    - Humans do care. Pick names that describe the data / value that they store"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Types\n",
    "- strings \n",
    "- integers & floats\n",
    "- booleans\n",
    "- None\n",
    "- lists & tuples\n",
    "- dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Every variable has a <b>type</b>, which refers to the kind of variable that it is, and how the computer stores that data. Python is <b>dynamically typed</b>; the variable type is determined at assignment.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common variable types\n",
    "\n",
    "|Variable Type|Definition |\n",
    "|---|:---|\n",
    "| String (`str`)  |  store characters, as text |\n",
    "| Integer (`int`)  | store signed, whole numbers |\n",
    "| Float (`float`)  | store signed, decimal-point numbers |\n",
    "| Booleans (`bool`)  | store <code>True</code> or <code>False</code> (capitalization matters) |\n",
    "| None (`NoneType`)  | special type that stores <code>None</code>, used to denote a null or empty value. |\n",
    "| Lists (`list`) & Tuples (`tup`)  |  collection of ordered items, that can be of mixed type (lists are mutable; tuples are immutable) |\n",
    "| Dictionaries (`dict`) |mutable collection of items, that can be of mixed-type, that are stored as key-value pairs   |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Declare a variable\n",
    "variable_name = 1.342\n",
    "\n",
    "# You can always ask Python 'what type is this variable' using:\n",
    "type(variable_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "- assignment\n",
    "- math\n",
    "- logical\n",
    "- comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment Operator\n",
    "\n",
    "- `=` for assignment\n",
    "\n",
    "There are additional assignment operators in Python, but this is the one you will use *all the time*, so we'll stick to this for now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math Operators\n",
    "\n",
    "\n",
    "- `+`, `-`, `*`, `/` for addition, subtraction, multiplication, & division\n",
    "- `**` for exponentiation & `%` for modulus (remainder)\n",
    "- `//` for floor division (integer division)\n",
    "- Follow the rules for order of operations (PEMDAS)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-14"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3-10)*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #4\n",
    "\n",
    "After executing the following code, what will be the value of `out`?\n",
    "\n",
    "https://forms.gle/FNLpvutU4BSNrr1W9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4\n",
    "b = 3\n",
    "c = 2\n",
    "out = a + b * c\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A) 0\n",
    "- B) 10\n",
    "- C) 14\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Python has comparison operators <code>==</code>, <code>!=</code>, <code><</code>, <code>></code>, <code><=</code>, and <code>>=</code> for value comparisons. These operators return booleans.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `==` : values are equal\n",
    "- `!=` : values are not equal\n",
    "- `<` : value on left is less than value or right\n",
    "- `>` : value on left is greater than value on right\n",
    "- `<=` : value on left is less than *or equal to* value on right\n",
    "- `>=` : value on left is greater than or equal to value on the right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #5\n",
    "\n",
    "How will the following expression evaluate?:\n",
    "\n",
    "https://forms.gle/8LaBNod64pvySex86"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 7\n",
    "b = '7'\n",
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A) True\n",
    "- B) False\n",
    "- C) None\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical (Boolean) operators\n",
    "- use Boolean logic\n",
    "- logical operators: `and`, `or`, and `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are named after the British mathematician - George Boole. He first formulated Boolean algebra, which are a set of rules for how to reason with and combine these values. This is the basis of all modern computer logic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Python has <code>and</code>, <code>or</code> and <code>not</code> for boolean logic. These operators return booleans.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `and` : True if both are true\n",
    "- `or` : True if at least one is true\n",
    "- `not` : True only if false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AND\n",
    "# will return True\n",
    "# both sides evaluate as true\n",
    "4==4 and 3 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# OR\n",
    "# will return True\n",
    "# one side evaluates as True\n",
    "4!=4 or 3 < 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "\n",
    "- `if`: checks a condition; using the `if` statement, and then only executes a set of code if the condition evaluates as `True`\n",
    "- `elif`: after an `if` statement, you can have any number of `elif`s (meaning 'else if') to check other conditions.\n",
    "- `else`: after an `if`, you can use an `else`that will run if the conditional(s) above have not run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alternative\n",
      "somethig that will always be executed no matter what condition_1 value\n"
     ]
    }
   ],
   "source": [
    "## example\n",
    "condition_1 = False\n",
    "condition_2 = False\n",
    "\n",
    "# if is required\n",
    "if condition_1:\n",
    "    print('This code executes if condition_1 evaluates as True.')\n",
    "    print('soemthing else too')\n",
    "    print('anothre thing to print')\n",
    "else: \n",
    "    print('alternative')\n",
    "    \n",
    "print('somethig that will always be executed no matter what condition_1 value')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Properties of conditionals\n",
    "\n",
    "- All conditionals start with an `if`, can have an optional and variable number of `elif`'s and an optional `else` statement\n",
    "- Conditionals can take any expression that can be evaluated as `True` or `False`. \n",
    "- At most one component (`if` / `elif` / `else`) of a conditional will run\n",
    "- The order of conditional blocks is always `if` then `elif`(s) then `else`\n",
    "- Code is only ever executed if the condition is met"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "A <b>loop</b> is a procedure to repeat a piece of code.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`while` loop** : repeat a piece of code while some condition is still met\n",
    "- **`for` loop** : repeat code for every element in a sequence.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`while` loops have the structure:\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    # Loop contents\n",
    "```\n",
    "\n",
    "While condition is true, execute the code contents. Repeat until condition is no longer True. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` loops follow the general structure:\n",
    "\n",
    "```python\n",
    "for item in iterable_variable:\n",
    "    # Loop contents\n",
    "```\n",
    "\n",
    "For each `item` in `iterable variable`, execute the code contents. Repeat until you reach last item in `iterable_variable`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicker Question #6\n",
    "\n",
    "What will the following loop print out?\n",
    "\n",
    "https://forms.gle/HqWg4rcDQHQeFZQ18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for loop 0\n",
      "if statement 0\n",
      "for loop 1\n",
      "for loop 2\n",
      "if statement 2\n",
      "for loop 3\n"
     ]
    }
   ],
   "source": [
    "my_lst = [0, 1, 2, 3]\n",
    "alistofstings = ['hi','there','everyone']\n",
    "\n",
    "for item in my_lst:\n",
    "    print('for loop',item)\n",
    "    if item % 2 == 0:\n",
    "        print('if statement',item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A) 0, 1, 2, 3\n",
    "- B) 0, 1\n",
    "- C) 0, 2\n",
    "- D) 1, 2, 3\n",
    "- E) 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "A function is a re-usable piece of code that performs operations on a specified set of variables, and returns the result.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general syntax for a function in Python is:\n",
    "\n",
    "```python\n",
    "# define a function: print_value\n",
    "# specify function parameters: num\n",
    "def print_value(num):\n",
    "    \n",
    "    # do some operation\n",
    "    print(num)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define function to determine if a value is even or odd\n",
    "def even_odd(value): \n",
    "    if (value % 2 == 0): \n",
    "        out = \"even\"\n",
    "    else: \n",
    "        out = \"odd\"\n",
    "    \n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute  function\n",
    "stored_output = even_odd(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'odd'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stored_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing code from modules, packages, and libraries\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<p>A <b>module</b> is a Python file that’s intended to be imported into scripts or other modules. It often defines members like classes, functions, and variables intended to be used in other files that import it.</p>\n",
    "\n",
    "<p>A <b>package</b> is a collection of related modules that work together to provide certain functionality. These modules are contained within a folder and can be imported just like any other modules. This folder will often contain a special __init__ file that tells Python it’s a package, potentially containing more modules nested within subfolders</p>\n",
    "\n",
    "<p>A <b>library</b> is an umbrella term that loosely means “a bundle of code.” These can have tens or even hundreds of individual modules that can provide a wide range of functionality.</p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lets import math... \n",
    "import math\n",
    "\n",
    "# the sqrt function lives inside the math namespace\n",
    "math.sqrt(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.32115521,  1.71281016, -0.75805707,  1.81018946,  1.49742089,\n",
       "       -0.62387965,  0.05535146,  0.62571893, -1.54371099, -0.65832481])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can pull just one thing from a library\n",
    "from scipy.stats import norm\n",
    "\n",
    "# now norm (the normal distribution) lives inside the global namespace, not inside scipy.stats\n",
    "norm.rvs(size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we can rename namespaces as we import them\n",
    "import seaborn as sns\n",
    "\n",
    "# typing sns is shorter than typing seaborn each time we use it\n",
    "sns.histplot( norm.rvs(size=1000) );"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![import antigravity and fly using python(joke)](https://imgs.xkcd.com/comics/python.png) \n",
    "https://xkcd.com/353/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging and writing code that's easy to debug\n",
    "\n",
    "parts of this are section are from https://jakevdp.github.io/PythonDataScienceHandbook/01.06-errors-and-debugging.html\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "Writing software is an iterative process, where finding problems and debugging your errors are standard procedure.  You will need to learn techniques and mindsets to help you do this.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Exceptions\n",
    "Most of the time when a Python script fails, it will raise an Exception. When the interpreter hits one of these exceptions, information about the cause of the error can be found in the traceback, which can be accessed from within Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func2(x):\n",
    "    a = x\n",
    "    b = x - 1\n",
    "    return func1(a, b)\n",
    "\n",
    "\n",
    "def func1(a, b):\n",
    "    return a / b\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/lc/h592vhs5421_z0kmg2tljk_40000gn/T/ipykernel_15747/2528727421.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 1/0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/var/folders/lc/h592vhs5421_z0kmg2tljk_40000gn/T/ipykernel_15747/3256142118.py\u001b[0m in \u001b[0;36mfunc2\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mfunc1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/var/folders/lc/h592vhs5421_z0kmg2tljk_40000gn/T/ipykernel_15747/3256142118.py\u001b[0m in \u001b[0;36mfunc1\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfunc1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "func2(1) # 1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't know exactly what an error means?  Or trying to figure out what to do about it?\n",
    "\n",
    "Well there's two options. You should definitely try debugging a bit, which we outline in the section below. This is the thing to do when the code is your code.\n",
    "\n",
    "But if you can't figure things out, and especially if the problem comes from inside an open source library you are using, well then its time to search the internet. \n",
    "\n",
    "![](https://i.redd.it/op96es9026wy.png)\n",
    "![](https://i.pinimg.com/736x/4d/86/ba/4d86bae4ec903fbc6b4e685cf66a14e4.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging: When Reading Tracebacks Is Not Enough\n",
    "The standard Python tool for interactive debugging is pdb, the Python debugger. This debugger lets the user step through the code line by line in order to see what might be causing a more difficult error. The IPython-enhanced version of this is ipdb, the IPython debugger.\n",
    "\n",
    "There are many ways to launch and use both these debuggers; we won't cover them fully here. Refer to the online documentation of these two utilities to learn more.\n",
    "\n",
    "In IPython, perhaps the most convenient interface to debugging is the %debug magic command. If you call it after hitting an exception, it will automatically open an interactive debugging prompt at the point of the exception. The ipdb prompt lets you explore the current state of the stack, explore the available variables, and even run Python commands!\n",
    "\n",
    "Let's look at the most recent exception, then do some basic tasks–print the values of a and b, and type quit to quit the debugging session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%debug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Partial list of debugging commands\n",
    "\n",
    "There are many more available commands for interactive debugging than we've listed here; the following table contains a description of some of the more common and useful ones:\n",
    "\n",
    "| Command         |  Description                                                |\n",
    "|-----------------|-------------------------------------------------------------|\n",
    "| ``list``        | Show the current location in the file                       |\n",
    "| ``h(elp)``      | Show a list of commands, or find help on a specific command |\n",
    "| ``q(uit)``      | Quit the debugger and the program                           |\n",
    "| ``c(ontinue)``  | Quit the debugger, continue in the program                  |\n",
    "| ``n(ext)``      | Go to the next step of the program                          |\n",
    "| ``<enter>``     | Repeat the previous command                                 |\n",
    "| ``p(rint)``     | Print variables                                             |\n",
    "| ``s(tep)``      | Step into a subroutine                                      |\n",
    "| ``r(eturn)``    | Return out of a subroutine                                  |\n",
    "\n",
    "For more information, use the ``help`` command in the debugger, or take a look at ``ipdb``'s [online documentation](https://github.com/gotcha/ipdb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing good code\n",
    "\n",
    "Learning how to write good software is the subject of many classes and a lifetime of learning. But let's start with the concept that you should write your code with tests built in. \n",
    "\n",
    "You want to think about edge cases and potential ways that the code could fail... \n",
    "- like what's the biggest or smallest a variable should be? \n",
    "- what does missing data look like, and what should be done if it happens?\n",
    "- does the sum of a bunch of numbers that represent a probability distribution really add up to 1?\n",
    "\n",
    "You can write tests into your code to ensure that conditions you expect to be true really are.  If they are not then it will generate an error and stop execution.\n",
    "\n",
    "In fact, errors are your best friend!  Much better to know you have a problem then to silently keep executing and produce a garbage answer.  Or keep executing and then fail much later when some stupid divide by zero happens and you have no idea why and can't trace it easily back to the source of the problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/lc/h592vhs5421_z0kmg2tljk_40000gn/T/ipykernel_15747/2851685787.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprob_dist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprob_dist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;31m# sum of probabilities should be 1!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "prob_dist = [0.1, 0.3, 0.6, 0.2]\n",
    "\n",
    "assert sum(prob_dist)==1 # sum of probabilities should be 1!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/lc/h592vhs5421_z0kmg2tljk_40000gn/T/ipykernel_15747/1725765139.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m# These are restuarant review stars, they should all be in the range of 0 - 5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mstars\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mstars\u001b[0m\u001b[0;34m<=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# we haven't introduced pandas yet, but you'll see lots more of this\n",
    "# it's a useful data handling library!\n",
    "import pandas as pd\n",
    "\n",
    "# this creates a Series... a way to hold several pieces of data\n",
    "# think of this like a list of data items, but with superpowers built in\n",
    "# in this case pretend we are holding information about restaurant review on Yelp\n",
    "# particularly this is the list of number of stars for a group of four restuarants\n",
    "stars = pd.Series([1, 2, -4, 3]) \n",
    "\n",
    "# These are restuarant review stars, they should all be in the range of 0 - 5\n",
    "assert (stars>=0).all() & (stars<=5).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1     True\n",
       "2    False\n",
       "3     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run this to understand the code (stars>=0).all()\n",
    "(stars>=0)\n",
    "# now what do you think .all() does?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python packages\n",
    "Packages (aka modules aka libraries) are collections of useful software.  When you type `import math` you get a bunch of software that helps you with math tasks. Importing a package gives you a namespace to grab the elements of the package from.  After importing the math package, `math.ceil(x)` will take a floating point number `x` and give you the ceiling of it... the smallest whole number larger than or equal to `x`. There's a ton of other things in the math package, and it will all be accessible to you inside the math namesapce once you import it: `math.isclose()`, `math.floor()`, etc.. \n",
    "\n",
    "Note the extra trick we did with the pandas package above.  Programmers are lazy.  Typing `pandas.Series` is too much for their poor fingers. So instead we do \n",
    "```python \n",
    "import pandas as pd\n",
    "```\n",
    "and now we can use the namespace like `pd.Series()` instead of `pandas.Series()` which would have happened without the `as pd` part of the import statement\n",
    "\n",
    "### Objects in Python\n",
    "The variable `stars` above is an \"object\" of type `pandas.Series`.  Like all objects, it contains both data (1,2, -4, 3) and a set of functions that can operate on that data (e.g., `.all()` or try `stars.sum()`).  \n",
    "\n",
    "Basically everything in Python is an object.  And most code you will write in datascience packages will use this kind of idea over and over again. A common trope you will see is something like what we saw above\n",
    "\n",
    "```python\n",
    "(stars>=0)\n",
    "```\n",
    "returned a new `pandas.Series` object the same size as `stars`. The object contained values of `True` or `False` for each entry in the series, corresponding to a test if that entry was bigger than or equal to zero (non-negative). The next step was to take that new series filled with Boolean values and ask \"is every value in this series `True`?\"  That's what happens when \n",
    "```python \n",
    "(...).all()\n",
    "```\n",
    "is called.  So the result is two steps... we evaluate a test on `stars`... that makes a new series of Booleans, and we test that series with the function `all()`... a function that is part of every `pandas.Series` object. \n",
    "\n",
    "NOTE: the period `.` says \"get me this thing on the right hand side of the period, which is part of the object on the left hand side of this period\".  In the case of `stars.sum()` it says call the function `sum()` which is part of the object `stars`.\n",
    "\n",
    "Want to know what functions a particular object has availble?  Type the name of the object instance (in this case it's `stars`... put a period after after it... and then press the \"tab\" key on your keyboard... you should see a scrollable list of all the things that are part of that object.\n",
    "\n",
    "Want to know more about an object? Type  `objectname?` and execute the cell to get contextual help\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stars. #put your cursor after the period and press tab now!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stars?"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}