Notebook 01 - Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Jupyter notebook is meant to introduce core Python ideas and the mechanisms of working with Jupyter notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything you see in a Jupyter notebook is contained in a notebook cell. There are a few main types of cells:\n",
    "\n",
    "* **Code cells** These are cells that contain Python code.\n",
    "* **Output cells** These are cells that contain any output that a Python code cell produces.\n",
    "* **Text/Markdown cells** These are cells that contain text, formatted in Markdown notation. These can be used to explain the code, or for you to take notes.\n",
    "\n",
    "Below is a code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 11\n",
    "\n",
    "# Lines that start with hash marks are comments and are ignored by Python.\n",
    "\n",
    "# Add x + y\n",
    "z = x + y\n",
    "\n",
    "# Print the sum\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 21 above is the output of the code, which in this case is just the output of the print statement.\n",
    "\n",
    "You can make more meaningful print statements as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is = 21\n"
     ]
    }
   ],
   "source": [
    "print(\"The sum is = \" + str(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the `+` sign means concatenate two strings together: the string `\"The sum is = \"` and the string representation of the number `z`: `str(z)`. Without the `str` around `z`, you would get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-a6ac6eadf2d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The sum is = \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "print(\"The sum is = \" + z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**It is important that you learn how to read an error message.** The easiest thing you can do is just read the bottom of the output, as this usually has the most immediate cause of the error. In this case, Python is telling us we cannot concatenate a string to anything other than a string.\n",
    "\n",
    "You can also concatenate several strings together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 10 and 11 = 21\n"
     ]
    }
   ],
   "source": [
    "print(\"The sum of \" + str(x) + \" and \" + str(y) + \" = \" + str(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a bit long. You can use formatted strings and Pythons `%` string operator to shorten this a bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 10 and 11 = 21\n"
     ]
    }
   ],
   "source": [
    "print(\"The sum of %d and %d = %d\"%(x, y, z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here `%d` is a placeholder for a whole number. See here for a detailed description of how to use `%` to format strings:\n",
    "* https://realpython.com/python-input-output/#the-string-modulo-operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other operations you can do with numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "-1\n",
      "110\n",
      "0.9090909090909091\n",
      "100000000000\n"
     ]
    }
   ],
   "source": [
    "# Add\n",
    "print(x + y)\n",
    "\n",
    "# Subtract\n",
    "print(x - y)\n",
    "\n",
    "# Multiply\n",
    "print(x * y)\n",
    "\n",
    "# Divide\n",
    "print(x / y)\n",
    "\n",
    "# Exponentiate\n",
    "print(x**y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other data types\n",
    "---\n",
    "\n",
    "Besides numbers and strings, you can work with other types of lists and dictionaries.\n",
    "\n",
    "## Dictionaries\n",
    "\n",
    "A dictionary lets you store values by key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kris\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\n",
    "    'fname': 'Kris',\n",
    "    'lname': 'Reyes',\n",
    "    'email': 'kreyes3@buffalo.edu'\n",
    "}\n",
    "\n",
    "your_name = my_dict['fname']\n",
    "print(your_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we create a dictionary with 3 entries. For example, the first entry has key `fname` and value `Kris`. We then access the dictionary using square brackets and a key: `my_dict['fname']`, which results in `Kris`.\n",
    "\n",
    "You can have empty dictionaries, add to an existing dictionary, and the dictionaries don't have to have the same types of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'title': 'Multivariate Statistics for Materials Informatics', 'number': 504, 'prof': {'fname': 'Kris', 'lname': 'Reyes', 'email': 'kreyes3@buffalo.edu'}}\n"
     ]
    }
   ],
   "source": [
    "# Create an empty dictionary\n",
    "my_class = {}\n",
    "\n",
    "# Add some entries to the dictionary\n",
    "\n",
    "# add a string value\n",
    "my_class['title'] = 'Multivariate Statistics for Materials Informatics'\n",
    "\n",
    "# add a number value\n",
    "my_class['number'] = 504\n",
    "\n",
    "# add a dictionary value\n",
    "my_class['prof']  = my_dict\n",
    "\n",
    "\n",
    "# you can print dictionaries\n",
    "print(my_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The printed out dictionary isn't nice to look at. We can \"prettify\" it, but we need another module called `pprint`, which we'll have to **import**. (Documentation: https://docs.python.org/3/library/pprint.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a module is imported in a Jupyter notebook, you can use it in any cell. Even cells above.\n",
    "\n",
    "Once imported, we can use it to print the dictionary nicely (after consulting the documentation on how to use it).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{   'number': 504,\n",
      "    'prof': {'email': 'kreyes3@buffalo.edu', 'fname': 'Kris', 'lname': 'Reyes'},\n",
      "    'title': 'Multivariate Statistics for Materials Informatics'}\n"
     ]
    }
   ],
   "source": [
    "pp = pprint.PrettyPrinter(indent=4)\n",
    "pp.pprint(my_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a bit better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Lists are an important part of Python. You can define lists with square brackets and a comma separated list of things. You can access a list using a integer index. Lists are zero-indexing, meaning you the first element of the list has an index of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 4, 8, 16, 32]\n",
    "\n",
    "print(my_list[0])\n",
    "print(my_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll get an error if you try to index into a list past the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-722781addfdd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\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;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(my_list[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error above says the index \"6\" is too big. Remember, even though the list has 6 elements, because of zero indexing, the largest index you can use is \"5\", and not \"6\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While so far we've been counting things from the left, we can also index things from the right using negative values. The right most element of the list can be accessed with a negative value -1. The second-to-the-right element has index -2, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "print(my_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "print(my_list[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have a list of any type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "how are you\n"
     ]
    }
   ],
   "source": [
    "str_list = [\"hello\", \"how are you\", \"good_bye\"]\n",
    "print(str_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even have a list of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16, 32]\n"
     ]
    }
   ],
   "source": [
    "list_list = [my_list, str_list]\n",
    "print(list_list[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello', 'how are you', 'good_bye']\n"
     ]
    }
   ],
   "source": [
    "print(list_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have a list of different types of values if you needed it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "mixed_list = [0, \"hello\"]\n",
    "print(mixed_list[0])\n",
    "print(mixed_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is secretly a list of characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character fourth from the right is = .\n"
     ]
    }
   ],
   "source": [
    "my_str = \"file_name.csv\"\n",
    "\n",
    "# The dot in the filename\n",
    "print(\"The character fourth from the right is = \" + my_str[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slice notation\n",
    "In addition to getting individual elements of a list, you can also get certain subsets of the list. This can be done using the slice notation.\n",
    "\n",
    "The slice notation can be used for extracting contigouous parts of a list. For example, to get the slice of letters from `my_str`, starting from the character at the 2nd index (`e`) up to (but not including) the character at the 7th index (`m`), you would do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e_na\n"
     ]
    }
   ],
   "source": [
    "my_substr = my_str[3:7]\n",
    "print(my_substr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's often useful to remember if you are slicing a list like `my_list[a:b]`, the resulting sublist with have `b-a` entries. For example, in the above, we are slicing from 3 to 7, which means we should expect 4 entries: `e`, `_`, `n`, and `a`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the first 3 entries, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fil\n"
     ]
    }
   ],
   "source": [
    "print(my_str[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a shortcut, you can omit `0` here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fil\n"
     ]
    }
   ],
   "source": [
    "print(my_str[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, this works for any list, not just a string. Recall `my_list = [1, 2, 4, 8, 16, 32]`. We can extract the first 3 entries as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print(my_list[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use negative numbers to slice from the right. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".cs\n"
     ]
    }
   ],
   "source": [
    "print(my_str[-4:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same logic holds here. It returns the slice starting at the character with index -4 (`.`), and all the characters up to (but not including) the character with index -1 (`v`). \n",
    "\n",
    "It's useful to understand that every character has two ways to index:\n",
    "\n",
    "```\n",
    "        string:   f   i   l   e  _  n  a  m  e  .   c   s   v\n",
    "positive index:   0   1   2   3  4  5  6  7  8  9  10  11  12\n",
    "negiatve index: -13 -12 -11 -10 -9 -8 -7 -6 -5 -4  -3  -2  -1  \n",
    "```\n",
    "\n",
    "\n",
    "To get the last 4 letters you can just omit the number on the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".csv\n"
     ]
    }
   ],
   "source": [
    "print(my_str[-4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can slice up to a negative index as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file_name\n"
     ]
    }
   ],
   "source": [
    "print(my_str[:-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This in particular is useful if you have an input CSV file, and you want to save the output file to a similarly named file but with a different extension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file_name.out\n"
     ]
    }
   ],
   "source": [
    "outfile = my_str[:-4] + '.out'\n",
    "print(outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List operations\n",
    "\n",
    "You can use several operators such as '+' or '*' to operate on lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [-10, -20, -30, -40, -50]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The '+' operator concatenates list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, -10, -20, -30, -40, -50]\n"
     ]
    }
   ],
   "source": [
    "print(list1 + list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The '*' operator repeats lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(list1*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because strings are lists, these operators apply to strings as well. We've already seen the concatenation operator on strings. The '*' operator works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "around the world around the world around the world around the world around the world around the world around the world around the world around the world around the world \n"
     ]
    }
   ],
   "source": [
    "print(\"around the world \"*10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The special *`len`* function returns how many elements are in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 elements in list 1\n"
     ]
    }
   ],
   "source": [
    "how_many = len(list1)\n",
    "print(\"There are %d elements in list 1\"%(how_many))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 10 elements in two copies of list 1\n"
     ]
    }
   ],
   "source": [
    "how_many = len(list1*2)\n",
    "print(\"There are %d elements in two copies of list 1\"%(how_many))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow\n",
    "---\n",
    "\n",
    "While we've been executing small **serial** programs, it would be nice to:\n",
    "\n",
    "* Conditional execution: perform different blocks of code depending on certain conditions.\n",
    "* Loop: repeat the same block of code, perhaps with different inputs \n",
    "* Functions: define and call functions or procedures \n",
    "\n",
    "Refer to the following tutorial for additional details:\n",
    "* https://docs.python.org/3/tutorial/controlflow.html\n",
    "\n",
    "Below we review how to do this in python\n",
    "\n",
    "## Conditional execution\n",
    "The main method for conditional execution in python are with **if statements**, which look like the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You passed!\n"
     ]
    }
   ],
   "source": [
    "grade = 63\n",
    "\n",
    "if grade > 60:\n",
    "    print('You passed!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we constructed a condition `(grade > 60)`, and defined a block of code that will execute if and only if the condition is true. Since the grade was preset to `63`, this condition is true, so the block of code is executed. If instead the grade as `40`, then the code won't execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 40\n",
    "\n",
    "if grade > 60:\n",
    "    print('You passed!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 2 important things to highlight\n",
    "* There is a colon `:` at the end of the `if` statement.\n",
    "* The conditional code block is idented.\n",
    "\n",
    "Indentation is important. It actually doesn't matter by how much or whether it is tab or spaces, but one convention is 4 spaces to indent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can provide an `else:` block follwing the `if` block to provide an alternative block that gets executed if the condition is false:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You failed :(\n"
     ]
    }
   ],
   "source": [
    "if grade > 60:\n",
    "    print('You passed!')\n",
    "else:\n",
    "    print('You failed :(')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can additionally check other conditions, and provide different blocks if those conditions are true using the `elif` statement. This works like the `if` statement, but is only executed if the conditions above it are all false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You got a C\n"
     ]
    }
   ],
   "source": [
    "grade = 73\n",
    "\n",
    "if grade > 90:\n",
    "    print('You got an A')\n",
    "elif grade > 80:\n",
    "    print('You got a B')\n",
    "elif grade > 70:\n",
    "    print('You got a C')\n",
    "elif grade > 60:\n",
    "    print('You got a D')\n",
    "else:\n",
    "    print('You failed :(')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The condition can be anything that evaluates to a Python `bool` data type. This includes\n",
    "* The basic `bool` types: `True` and `False.\n",
    "* Combinations of conditionals\n",
    "* Special functions that return a true or false value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will always execute\n",
      "You got a C\n",
      "You got a C\n",
      "{'fname': 'Kris', 'lname': 'Reyes', 'email': 'kreyes3@buffalo.edu'}\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"This will always execute\")\n",
    "    \n",
    "if False:\n",
    "    print(\"This will never execute\")\n",
    "\n",
    "# You can combine conditions using and, or, not or other logical operators\n",
    "if grade > 70 and grade < 79:\n",
    "    print('You got a C')\n",
    "    \n",
    "# If using inequalities, then you can combine them using this short cut\n",
    "if 70 < grade < 79:\n",
    "    print('You got a C')\n",
    "\n",
    "if not grade > 60:\n",
    "    print('You failed')\n",
    "    \n",
    "# special functions will also return true or false statements\n",
    "if 'prof' in my_class:\n",
    "    print(my_class['prof'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very special condition is to check whether a variable has been set to the `None` type, which is a special type in Python. This is often used when a variable is optional in an analysis, or has not been correctly set. In this case, the preferred method for checking this condition is to use `is None`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No data yet!\n"
     ]
    }
   ],
   "source": [
    "data = None\n",
    "\n",
    "if data is None:\n",
    "    print('No data yet!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "There are lots of ways to loop or iterate code in Python. The most basic way is with the `for loop`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "for list_element in my_list:\n",
    "    print(list_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is code that loops over every entry in the list `my_list`. Here, `list_element` will represent some element in `my_list`. The indented code is executed on that element, and then `list_element` gets set to the next element of the list, and this process is repeated until every element has been iterated over.\n",
    "\n",
    "In the example, we simply print out that element, but you can imagine doing something more complicated for every element. Let's calculate the sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the list sum to be 0\n",
    "list_sum = 0\n",
    "\n",
    "# iterate over every element in the list\n",
    "for list_element in my_list:\n",
    "    # add this element to the sum\n",
    "    list_sum = list_sum + list_element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63\n"
     ]
    }
   ],
   "source": [
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**N.B.** You can use the `+=` operator to shorten line 7 a bit from\n",
    "\n",
    "```\n",
    "    list_sum = list_sum + list_element\n",
    "```\n",
    "to\n",
    "\n",
    "```    \n",
    "    list_sum += list_element\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, you may want to iterate over the numbers from `0, 1, 2, ..., N-1`, for example, to loop over indices of a list. Instead of build a list with those elements, you can use the built-in function `range(N)` to build something similar for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can do something else inside the `for-loop`. Below we'll use the modulo operator `%`, which returns the remainder after division. We use it here to check the remainder after dividing by 2. If it is 0 (i.e. if the number is even), then we'll print it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    # check if even\n",
    "    if i % 2 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be similarly done by going from 0 to 10, but stepping by two each iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehensions\n",
    "\n",
    "Consider the following loop that squares every element in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "squared = []\n",
    "for list_element in my_list:\n",
    "    squared_element = list_element**2\n",
    "    squared.append(squared_element)\n",
    "    \n",
    "print(squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While simple, this example highlights a very common pattern we often encounter when working with and manipulating lists. That is, we do some operation to every element of some list, and save the result to another list. In this way the elements of the resulting list correspond to the elements of the original one. This is such a common pattern that Python has a shortcut to do this in one line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "squared = [ list_element**2 for list_element in my_list]\n",
    "print(squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called a list comprehension, and it's very useful for writing succinct code. However, it's considered **syntatic sugar** -- there is nothing magical or extra happening in a list comprehension that wouldn't happen in a similarly simple `for`-loop.\n",
    "\n",
    "While the above element processes and adds a new element to `squared` for each and every element from `my_list`, you can add conditionals to the list comprehension to conditionally add elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16, 25]\n"
     ]
    }
   ],
   "source": [
    "small_squared = [list_element**2 for list_element in my_list if list_element > 3]\n",
    "print(small_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code will only add a new element to the resulting `small_squared` list if `list_element` is larger than 3.\n",
    "\n",
    "List comprehensions can get fairly complex, and so use them with some reservation, as short, succinct but hard-to-understand code is just as bad as longer code. As with most things in life, your goal as a programmer is to strike a balance. Later, we'll explore a different way of performing operations on list elements one-by-one using the `numpy` library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions allow you to modularize your programming by moving common code blocks to a single location for use throuhgout your other blocks of code. Functions therefore promote abstraction, code-reuse and maintainability -- all good things for programming.\n",
    "\n",
    "To define a function, you will use the `def` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_four_numbers(a, b, c = 0, d = 1):\n",
    "    return a + b + c + d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above function definition:\n",
    "\n",
    "1. Starts with the `def` keyword.\n",
    "2. Specifies a function name: `add_four_numbers`.\n",
    "3. States that the function has 2 required arguments and two optional arguments.\n",
    "4. Names the 2 required arguments as `a` and `b`\n",
    "5. Names the optional arguments `c` and `d`, and provides the default values of 10 and 1 if one or both of them are not specified.\n",
    "6. Does some calculations and returns the result of a function, which in this case is the sum of `a`, `b`, `c`, and `d`.\n",
    "\n",
    "To call the function, we just use the function name and specify at least 2 arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "result = add_four_numbers(3, 4, 1, 3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't specify any of the optional arguments, the function will just use their default values in the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "result = add_four_numbers(1, 2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to specify a value for one of the optional arguments, you can refer to it directly in your function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "result = add_four_numbers(1, 2, d = 10)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Flipping a biased coin\n",
    "---\n",
    "\n",
    "Write a function `count_heads` that counts how many heads are obtained by flipping a biased coin several times. The function should take 1 required input `n` which is the number of times to flip the coint. The function should also take in an optional argument `p`, which is the probability of seeing a head after a coin flip. Let `p = 0.5` be the default value. The function should return the number of flips that resulted in a head.\n",
    "\n",
    "To simulate the flipping of a biased coin, you can use the `random.random()` function inside the `random` module.\n",
    "This function returns a number uniformly distributed between 0 and 1. Thus if `random.random() < p`, you can count this as a \"Heads\".\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code goes here.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Fizz Buzz\n",
    "---\n",
    "\n",
    "Print the numbers 1 through 100, except:\n",
    "1. print \"Fizz\" if the number is divisible by 3, \n",
    "2. print \"Buzz\" if the number is divisible by 5,\n",
    "3. print \"FizzBuzz\" if the number is divisible by 3 and 5.\n",
    "\n",
    "You may want to use the `%` operator: for 2 numbers `x` and `y`, `x%y` is the remainder of the division of `x` by `y`. In particular if `x` is divisible by `y`, then `x%y == 0`.\n",
    "\n",
    "\n",
    "You *may* want to know that to not print a new line after `print` statement, you can say:\n",
    "```\n",
    "print(\"hello\", end=\"\")\n",
    "```\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code goes here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra Reading\n",
    "---\n",
    "\n",
    "## Python \n",
    "* https://www.python.org/about/gettingstarted/\n",
    "* https://wiki.python.org/moin/IntroductoryBooks\n",
    "* https://diveintopython3.net/\n",
    "\n",
    "## Numpy/Scipy/Scikit-learn\n",
    "* https://numpy.org/devdocs/user/quickstart.html\n",
    "\n",
    "\n",
    "## Jupyter\n",
    "* https://realpython.com/jupyter-notebook-introduction/\n",
    "* https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/index.html\n",
    "\n",
    "    \n",
    "## Markdown\n",
    "* https://www.datacamp.com/community/tutorials/markdown-in-jupyter-notebook\n",
    "* https://commonmark.org/help/tutorial/\n",
    "* https://www.markdownguide.org/getting-started\n"
   ]
  }
 ],
 "metadata": {
  "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.8.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}