01_01_python-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RQlGWCt2xi6F",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Course Announcements**\n",
    "- Zoom idea dropped -> too many problems, podcast lectures anyway, participation points on canvas  \n",
    "- A1_Q5 issues\n",
    "- **Discussion Lab**: for finding group mates\n",
    "- Group formation deadline is end of week 2. The signup form is up.\n",
    "- **My OH**: by appt. thus far\n",
    "    -\n",
    "- **datahub**: where discussion labs and assignments will be released\n",
    "    - Problems with datahub seem to be resolved finally\n",
    "    - Practice Assignment is up  \n",
    "    - D1 and A1 are up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AiFxW2L06-mt"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/COGS108/Lectures-Wi22/blob/main/01_intro/01_02_python.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rZiFrafRxi6G"
   },
   "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": {
    "id": "Zy4aeN56xi6H"
   },
   "source": [
    "#### Jupyter Notebooks\n",
    "- Markdown\n",
    "- code cells\n",
    "- kernel\n",
    "- jalopnik.com\n",
    "* nytimes.com\n",
    "- to add an element\n",
    "\n",
    "write **wahtaver** \n",
    "\n",
    "1. firs tthing\n",
    "1. second thing\n",
    "1. third\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7wETVn2kxi6H"
   },
   "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TOka2jsIxi6H"
   },
   "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": {
    "id": "OrmtzQ4Axi6I"
   },
   "source": [
    "## Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "muUfcSwyxi6I"
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "The main organizational structure of the notebook are <b> cells </b>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S_ejc_d-xi6I"
   },
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o_HKhXpPxi6J"
   },
   "source": [
    "### Markdown Cells\n",
    "\n",
    "Cells, can be markdown (text), like this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UVv77qnhxi6J"
   },
   "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": {
    "id": "VTN5Tbn2xi6J"
   },
   "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": {
    "id": "Jc911wz5xi6K"
   },
   "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": {
    "id": "acyl5E28xi6K"
   },
   "source": [
    "### Question #1\n",
    "\n",
    "**Which does three underscores around text accomplish?**\n",
    "\n",
    "\n",
    "- A) bold\n",
    "- B) italicize\n",
    "- C) bold + italicize\n",
    "- D) normal text\n",
    "- E) I'm lost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0DizVOyvxi6K"
   },
   "source": [
    "___Use this cell to determine the answer to the question.___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wsrHQzaExi6K"
   },
   "source": [
    "### Question #2\n",
    "\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": {
    "id": "34XUBJWYxi6L"
   },
   "source": [
    "test it out down here to see...\n",
    "\n",
    "1. list item\n",
    "2. list item\n",
    "3. list item\n",
    "4. hiya"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EUn6Uc_bxi6L"
   },
   "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": null,
   "metadata": {
    "id": "wDQYP9isxi6L"
   },
   "outputs": [],
   "source": [
    "# Cell can also be code.\n",
    "a = 1\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YJi_vTxvxi6M",
    "outputId": "e45145a2-c608-4c7b-8dc1-91120599f944"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "id": "KwohsYHNxi6M",
    "outputId": "204444a5-5902-4bd2-966a-7f1f8d4dd50e"
   },
   "outputs": [],
   "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": {
    "id": "Xdk0NToYxi6M"
   },
   "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": {
    "id": "NednMgR8xi6N"
   },
   "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": {
    "id": "UNuUepeVxi6N"
   },
   "source": [
    "## Python Review\n",
    "\n",
    "- variable assignment\n",
    "- variable types\n",
    "- operators\n",
    "- conditionals\n",
    "- loops\n",
    "- functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_VpfoP-Sxi6N"
   },
   "source": [
    "### Variable Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tF-xKVenxi6O"
   },
   "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": null,
   "metadata": {
    "id": "wBqxnEsBxi6O"
   },
   "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": null,
   "metadata": {
    "id": "JW78l019xi6O",
    "outputId": "186fedb4-93d6-4ba2-e866-f40ad227d74a"
   },
   "outputs": [],
   "source": [
    "# once you create a variable it's stored in your namespace\n",
    "my_variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-8oBdjOCxi6O"
   },
   "source": [
    "### Question #3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oA97aexAxi6P",
    "outputId": "a453057e-47c1-4e3c-dab5-72be6e3c84e7"
   },
   "outputs": [],
   "source": [
    "a = 29\n",
    "a = 'string'\n",
    "a\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ScpUvabwxi6P"
   },
   "source": [
    "**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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a == 'string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gjwP4qH5xi6P"
   },
   "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": {
    "id": "lfT8h1Afxi6P"
   },
   "source": [
    "Math: What is x?\n",
    "\n",
    "$y = 10x + 2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9QVylMfIxi6P"
   },
   "source": [
    "Code: What is x?\n",
    "\n",
    "`x = x + 1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6-_9vEzvxi6Q"
   },
   "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": {
    "id": "7P4S6A5gxi6Q"
   },
   "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": {
    "id": "ucBFR9Zoxi6Q"
   },
   "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": {
    "id": "W15Gex80xi6Q"
   },
   "source": [
    "### Variable Types\n",
    "- strings \n",
    "- integers & floats\n",
    "- booleans\n",
    "- None\n",
    "- lists & tuples\n",
    "- dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ripbpXS9xi6R"
   },
   "source": [
    "## Variable Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qQpCelCBxi6R"
   },
   "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": {
    "id": "by79RBEkxi6R"
   },
   "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": null,
   "metadata": {
    "id": "x3Va7Ulpxi6R",
    "outputId": "7777f5c2-423a-4476-e12e-ed8fb8385d9a"
   },
   "outputs": [],
   "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": {
    "id": "iixn9TmGxi6S"
   },
   "source": [
    "## Operators\n",
    "- assignment\n",
    "- math\n",
    "- logical\n",
    "- comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mKh6spMyxi6S"
   },
   "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": {
    "id": "yfS-KmIXxi6S"
   },
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3-10)*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wCA1We7Txi6S"
   },
   "source": [
    "###  Question #4\n",
    "\n",
    "After executing the following code, what will be the value of `out`?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "beCNzOOOxi6S",
    "outputId": "789de67c-8a55-4475-a01f-c68181fa52be"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 4\n",
    "b = 3\n",
    "c = 2\n",
    "out = a + b * c\n",
    "out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oCsEdPiMxi6T"
   },
   "source": [
    "- A) 0\n",
    "- B) 10\n",
    "- C) 14\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v-POJMUNxi6T"
   },
   "source": [
    "### Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R58Qnh-txi6T"
   },
   "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": {
    "id": "mKt9X06Txi6T"
   },
   "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": {
    "id": "yeqk_2ogxi6U"
   },
   "source": [
    "### Question #5\n",
    "\n",
    "How will the following expression evaluate?:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "xnZW_ayUxi6U",
    "outputId": "23907e83-63af-4b77-a39f-9cac29bccbdf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 7\n",
    "b = '7'\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "r1vvs7Sbxi6U",
    "outputId": "f50b4f3b-b38e-47d0-c0ba-2f72356fd9e9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# when a float and int\n",
    "# will compute as equivalent\n",
    "1.0 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nSHChTxTxi6U"
   },
   "source": [
    "- A) True\n",
    "- B) False\n",
    "- C) None\n",
    "- D) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EjgUJNMcxi6U"
   },
   "source": [
    "### Logical (Boolean) operators\n",
    "- use Boolean logic\n",
    "- logical operators: `and`, `or`, and `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CTY1DL1vxi6V"
   },
   "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": {
    "id": "rmkdRrjZxi6V"
   },
   "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": {
    "id": "woUgapzPxi6V"
   },
   "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": null,
   "metadata": {
    "id": "FSCS3vg3xi6V",
    "outputId": "3d516e93-12e4-4c0e-abeb-1512a26ceb08"
   },
   "outputs": [],
   "source": [
    "# AND\n",
    "# will return True\n",
    "# both sides evaluate as true\n",
    "4==4 and 3 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kv4sqZN2xi6V",
    "outputId": "fa21996b-8503-4971-9e86-406fc47813b8"
   },
   "outputs": [],
   "source": [
    "# OR\n",
    "# will return True\n",
    "# one side evaluates as True\n",
    "4!=4 or 3 < 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D6JC3_65xi6W"
   },
   "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": null,
   "metadata": {
    "id": "hLgxlV6dxi6W",
    "outputId": "b92cf184-521f-42fb-b21b-efa08929cbbb"
   },
   "outputs": [],
   "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": {
    "collapsed": true,
    "id": "r4okQQXpxi6W"
   },
   "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": {
    "id": "LO5iI1Nhxi6W"
   },
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gv1Sx6kvxi6X"
   },
   "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": {
    "id": "MPOP5ph-xi6X"
   },
   "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": {
    "id": "5FG5HjZaxi6X"
   },
   "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": {
    "id": "tX853dYqxi6X"
   },
   "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": {
    "id": "V8_zRBy7xi6Y"
   },
   "source": [
    "### Clicker Question #6\n",
    "\n",
    "What will the following loop print out?\n",
    "\n",
    "https://forms.gle/HqWg4rcDQHQeFZQ18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "C0dvF-ylxi6Y",
    "outputId": "409ade4b-a751-4b19-a10a-5029c1495c7c",
    "scrolled": false
   },
   "outputs": [],
   "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": {
    "id": "D2wKay-9xi6Y"
   },
   "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": {
    "id": "DeSi5e7dxi6Y"
   },
   "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": {
    "id": "REM2y_2jxi6Y"
   },
   "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": null,
   "metadata": {
    "id": "FIbZqA0Yxi6Z"
   },
   "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": null,
   "metadata": {
    "id": "AZiinHoGxi6Z",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Execute  function\n",
    "stored_output = even_odd(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZaWC03ZBxi6Z",
    "outputId": "3d550a8a-ae9a-46c4-f617-62df6316bb1b"
   },
   "outputs": [],
   "source": [
    "stored_output"
   ]
  },
  {
   "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": [
    "IPython contains tools to streamline this process. This section will briefly cover some options for controlling Python's exception reporting, followed by exploring tools for debugging errors in code.\n",
    "\n",
    "### Controlling Exceptions: %xmode\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. With the %xmode magic function, IPython allows you to control the amount of information printed when the exception is raised. Consider the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func2(1) # 1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling func2 results in an error, and reading the printed trace lets us see exactly what happened. By default, this trace includes several lines showing the context of each step that led to the error. Using the %xmode magic function (short for Exception mode), we can change what information is printed.\n",
    "\n",
    "%xmode takes a single argument, the mode, and there are three possibilities: Plain, Context, and Verbose. The default is Context, and gives output like that just shown before. Plain is more compact and gives less information. You probably don't want that, but feel free to explore.\n",
    "\n",
    "When you have a code problem, you may want to use the Verbose mode, it adds some extra information, including the arguments to any functions that are called:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%xmode Verbose\n",
    "func2(1)"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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",
    "stars = pd.Series([1, 2, -4, 3]) # resuarant review stars, should be 0 - 5\n",
    "\n",
    "assert (stars>=0).all() & (stars<=5).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "name": "01_02_python.ipynb",
   "provenance": []
  },
  "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.11.1"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}