01-Getting started with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python as a calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if you don't know any Python, you can start to use it as a calculator!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: Convert from inches to cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12 * 2.54"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: Converting from Celcius to Fahrenheit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "37.5 * 9 / 5 + 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python respects the standard arithematic [operator precedence](https://docs.python.org/3/reference/expressions.html#operator-precedence) as you would expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "50 - (4 * 7 / 2 + 6) * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One catch is that you would need to use `**` (and not `^`) to do exponentiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute how many kg are in 12 lb. (Hint: 1 lb ~ 0.45 kg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the average of the following values: 7.4, 11.9, 6.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the sample variance of the following values: 7.4, 11.9, 6.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint 1: sample variance $\\sigma^2$ is \n",
    "\n",
    "$$\n",
    "\\sigma^2 = \\frac{1}{N-1} \\sum_{i=1}^N(x_i - \\mu)^2\n",
    "$$\n",
    "\n",
    "where $N$ is the number of samples, $x_i$ is the $i^\\text{th}$ sample, and $\\mu$ is the mean (average) of the samples.\n",
    "\n",
    "Hint 2: Use mean computed from Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing values into variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you start to work with more (complex) computations, the same value may need to be used multiple times, and you wouldn't want to type them in everytime. In particular, this is inefficient if you want to change the value and recompute!\n",
    "\n",
    "You can save a lot of time by storing important values into **variables** - a piece of computer memory that can hold a value under a name of your choice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You create a new variable by picking a *variable name* and **assigning** a value to it with the `=` (assignment) operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has successfully created a new variable called `celsius`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the variable's content by simply typing in the variable name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use variables in place of the value it holds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x**2 - 5 * x + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use variables to store a few values, and then compute their mean and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = -8\n",
    "c = 9\n",
    "\n",
    "(a + b + c) / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compute the variance, let's go ahead and store the computed mean into a variable called `mean` as well!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the mean\n",
    "mean = (a + b + c) / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that I have now added a **comment** to my code. In Python, anything that follows a hash symbol (`#`) until the end of the line is considered to be a comment and would not affect the computation. Rather it is there for others and yourself to explain what you are doing in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute variance\n",
    "var = ((a - mean)**2 + (b - mean)**2 + (c - mean)**2) / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go ahead and change the values of the cell defining variables `a`, `b`, and `c`, and run the cells to compute the new mean and variance. Do you now see how variables can save you from repetetive typing?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create two variables to store two numbers. Now compute the sum and product of the two numbers, and store them into variables as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One very cool feature of Python is its ability to perform multiple assignments at once. What do you think would happen with the following?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 1, 2, 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As long as the number of elements match on both sides of `=` symbol, Python will happily assign values on the right to variables at the corresponding position on the left. A very cool use of this is **variable swapping**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "y = 1\n",
    "\n",
    "# swap variable values\n",
    "x, y = y, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# On the tangent: Good variable names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is a good variable name?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As your computation gains complexity, you would want to start printing out messages and results of your computation, nicely formatted to aid the understanding. You can easily do so using the `print` Python function: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Good morning!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values surrounded by quotes `'` and double quotes `\"` are called **strings** and are used to represent a _string of characters_ as in the case of `\"Good morning!\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print can also be used to print out numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(100.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also put **expressions** inside the `print`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(100 + 10 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print multiple things side by side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Height\", 189, \"Age\", 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course, you can print out variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100\n",
    "print(\"x=\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every programming textbook makes you print \"Hello, World!\" - let's go ahead and get that down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing out results of your computation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Armed with `print`, you can report the results of your computation a bit more nicely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = -8\n",
    "c = 9\n",
    "\n",
    "# compute mean\n",
    "print(\"Computing mean...\")\n",
    "mean = (a + b + c) / 3\n",
    "\n",
    "# compute variance\n",
    "print(\"Computing variance...\")\n",
    "var = ((a - mean)**2 + (b - mean)**2 + (c - mean)**2) / 2\n",
    "\n",
    "print(\"mean=\", mean)\n",
    "print(\"variance=\", var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More about strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While you can use `print` to print some text (string) side-by-side with numbers (say as stored in variables), you may not get it in the exact format you want.\n",
    "\n",
    "For that you can **format a string** using `format` call onto the string as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 123.45678\n",
    "\n",
    "print('The value of x = {}'.format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 30\n",
    "total = a + b\n",
    "print('a={}, b={}, and a+b={}'.format(a, b, total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We say that the values of the variables were **interpolated** into the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format provides you with special syntax that let's you control how the variable values are modified before getting interpolated into the string. For example, you might want to limit how many digits are shown to the right of the decimal point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 123.456789\n",
    "print('The value is {:.2f}'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The formatting specification starts with `:` and here `.2f` means show up to two decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations on strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like you can perform operations on numbers, it turns out that you can perform some operations on strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello \" + \"World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello! \" * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello \" - \"ello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing String values in variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like numbers, you can store any string value into a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine string formatting and operations to construct more complex string values out of simpler strings and numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = \"Edgar\"\n",
    "last_name = \"Walker\"\n",
    "\n",
    "full_name = first_name + \" \" + last_name\n",
    "\n",
    "greeting = \"Hello! My name is {}!\".format(full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store your first name, last name, and favorite food into separate variables (give each a meaningful name!) Now construct a single string that introduces your full name and your favorite food. Finally, printout your string for the world to see!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus far, we have encountered a few **data types** in Python. Data type of a value specifies the expected meaning and operations that are allowed on the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(1.053)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('hello!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each of these types, the written out values are called the **literals**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# integer literal\n",
    "118"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# float literal\n",
    "5.79"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string literal\n",
    "\"testing\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another string literal\n",
    "'message'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We often refer to the type of the value stored in a variable as the **type of the variable**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, in Python, a variable can take in values of any type, regardless of what was assigned to it previously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "print('x stores {}'.format(type(x)))\n",
    "\n",
    "x = 'hello'\n",
    "print('x now stores {}'.format(type(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will get back to what exactly the term `class` means here, later in the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are far more than `int`, `float` and `str` data types in Python, and we'll cover more as we encounter them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you think would happen with the following?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = '20'\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you would want to **convert from one data type to another** where it makes sense. If a string represents valid number, you can convert them into an integer or float with `int()` and `float()` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = '20'\n",
    "\n",
    "a + int(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float('30.4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store two string representing numbers into two variables. Add them together and see what you get. Next, convert them to `float` values and add them again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storage of simple data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we move on, let's take a look what happens when two or more variables \"share\" data: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = a\n",
    "\n",
    "print('a = {}, b = {}'.format(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now what happens if I change the value of `b`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 15\n",
    "\n",
    "print('a = {}, b = {}'.format(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simple data types like `int`, `float`, and `str`, when two (or more) variables (e.g. `a` and `b`) are set to each other, it is best to think that the **values are copied over**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structured data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While simple data types like `int` and `str` are suitable for representing a single value at a time, we often want to group multiple values together into some sort of a **data strcuture**. Python comes with a few built-in **structured data types** that let's you organize your data better. Here, we are going to take a look at the two of the essential built-in data structures of Python: **lists and dictionaries**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Especially in scientific computing, you often encounter a sequence of values - e.g. time series of spike rates, or behavioral responses from multiple mice. You could imagine storing each value into a separate variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# e.g. drug responses\n",
    "day1 = 10.5\n",
    "day2 = 30.2\n",
    "day3 = 50.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but this soon results in an overwhelming number of variables that becomes hard to manage. Instead, you can construct **a list of values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses = [10.5, 30.2, 50.8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(responses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List can hold numbers and strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = ['Tokyo', 'Houston', 'Trondheim', 'New York']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing into the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list lets you keep multiple values together in one variable, and maintains the order. You can access an element or **index into** the list using `[]` syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gets the value at index 0\n",
    "responses[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in Python, **index starts at 0**!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also index from the end using negative numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the last element\n",
    "responses[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the second to last element\n",
    "responses[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you try to access index beyond the total number of elements?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find out the total number of elements using `len()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(responses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding elements to a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw that we can create a list with values inside using `[val1, val2, val3, ...]` syntax. We could also just start with an empty list, and **append** values to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = [] # start with an empty list\n",
    "\n",
    "# append values one at a time\n",
    "dogs.append('Dobermann')\n",
    "dogs.append('Siberian Husky')\n",
    "dogs.append('Pug')\n",
    "\n",
    "print(dogs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can start with a non empty list, and add more values later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages = ['Python', 'MATLAB']\n",
    "\n",
    "print(languages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages.append('C++')\n",
    "languages.append('JavaScript')\n",
    "\n",
    "print(languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a list **starting with** at least 4 elements. Now add two more elements to the list.\n",
    "\n",
    "Finally, practice indexing into each element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixed types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may be surprised to find out that Python's list is a mixed type list - that is, a list can contain any mixture of data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list = [10, 'Apple', 105.212]\n",
    "print(mixed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very important property of a list is its **mutability**. This is best illustrated by an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a list with three elements\n",
    "values = ['A', 'B', 'C']\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now change an element of the list **in-place**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values[1] = 'X'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing elements from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['dog', 'cat', 'sheep', 'tiger', 'mouse', 'monkey']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can remove any unwanted elements **at a specified index** from a list using `del` command or `pop` method:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using *del*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# delete element at index 1\n",
    "del animals[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see the list again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using *pop* method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `pop` method removes the item at the index **and returns the removed element**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "removed = animals.pop(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(animals)\n",
    "print('Removed ', removed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fix the list below to only contain animal names. Also, fix the spelling of the word `'dolphin'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['dlphn', 10, 'popcorn', 'dog', 'tiger', 'table', 'computer']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now look at a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already learned how to access one element at a time with `[index]`, but what if **we want to get the first three elements** in a separate list? How about the **last three elements**?\n",
    "\n",
    "Well there is **slicing** for that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can **slice** a list to create a new list that contains a subset of the elements. The syntax follows `list[start:stop:skip]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Take first three elements:\n",
    "\n",
    "characters[0:3] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we **start at index 0 (item 'a')** and **end at index 3 (item 'd')** but the last item is **not** included in what's returned. If you say `0:3`, it return items at index 0, 1, and 2, but not 3!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can slice from the end of the list using negative index. Let's get the last three elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Noticed that I didn't specify the end? If you leave the `end` index out, it will automatically go to and **include** the last element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact you can also skip the `start` index, defaulting to 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first 5 elements = index 0, 1, 2, 3, and 4\n",
    "characters[:5]   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we can add *step* as the third number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters[0:6:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you see what happened? The last number specifies steps to take between elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ignore `start` and `stop`, and just specify the `step`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get every other elements\n",
    "characters[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now can you guess what the following would do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithematics operators on lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly you can perform some arithematic operations like `+` and `*` on lists. Let's look at them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Addition (+)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you think would happen below?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_list = ['a', 'b', 'c']\n",
    "second_list = ['x', 'y', 'z']\n",
    "\n",
    "print(first_list + second_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiplication (\\*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "messages = ['Hello!', 'World']\n",
    "\n",
    "print(messages * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While lists are nice for holding a collection of similar values, especially if the order matters, it may not be suitable for some needs. For example, what if I want to represent **all of my experimental setup** including which mouse was used, the date, and the stimulus protocol? You could imagine doing something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stores mouse ID, experiment date, and stimulus protocol\n",
    "setups = [1234, '2018-07-01', 'orientation classification']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem is that it is not immediately obvious what value stands for what, and also usage is a bit awkward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Experiment date', setups[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rather than using the **position in the list**, we would much rather use a more descriptive label or a **key** to store and access a value -- well, that's exactly what a **dictionary** is for!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You create a dictionary by specifying a series of **key-value** pairs as follows, all within `{}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setups = {\n",
    "    \"mouse_id\": 1234,\n",
    "    \"date\": \"2018-07-01\",\n",
    "    \"protocol\": \"orientation classification\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at what we have created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that for each piece of information (e.g. mouse id `1234`), we have associated a `key` (i.e. `\"mouse_id\"`). This helps to make it more obvious what each piece of information is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new dictionary containing your `\"name\"`, `\"age\"`, and `\"hobby\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing items in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary wouldn't be quite useful if we cannot access it's content. Just like `lists`, you can **index into** a dictionary using `[]`. However, we make use of the **keys** instead of the numerical index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the value for the key \"mouse_id\"\n",
    "print('Mouse id is', setups['mouse_id'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you try to access an element that doesn't exist?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# key \"experimenter\" doesn't exist!\n",
    "setups[\"experimenter\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding elements into a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like lists, you can add more elements into the dictionary after it's created. However, unlike lists, we do not use `append` method. Rather, we just go ahead and assign a new value into the key!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setups['experimenter'] = 'Edgar Walker'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# take a look at the dictionary\n",
    "setups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact you could have started out with an empty dictionary and add element one at a time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gene lookup table - starting out empty\n",
    "gene = {}\n",
    "\n",
    "gene['mouse1'] = 'WT'\n",
    "gene['mouse2'] = 'Hb+/-'\n",
    "gene['mouseX'] = 'Unknown'\n",
    "\n",
    "gene"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can modify the value of an existing entry by simply assigning a new value to the key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# change the date\n",
    "setups['date'] = \"2018-01-01\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deleting an entry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To delete an entry from the dictionary, you can use either `del` command or `pop` method, just like for lists!\n",
    "Starting with a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = {\n",
    "    'Houston': 95,\n",
    "    'Chicago': 82,\n",
    "    'Tokyo': 76,\n",
    "    'Trondheim': 50,\n",
    "    'Seattle': 69\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del temperatures['Tokyo']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "removed = temperatures.pop('Trondheim')\n",
    "\n",
    "temperatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "removed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By adding new items, modifying existing ones, and deleting unwanted items, take the dictionary below and turn it into the following:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "{\n",
    "    \"setup\": 5,\n",
    "    \"experimenter\": YOUR NAME HERE,\n",
    "    \"subject_id\": 35,\n",
    "    \"trial counts\": 300\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    \"experimenter\": \"ANONYMOUS\",\n",
    "    \"subject_id\": 35,\n",
    "    \"trial counts\": 0,\n",
    "    \"weather\": \"cloudy\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Immutable vs mutable data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sharing simple values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we move on, let's take a look at **what happens if you set two (or more) variables equal to each other**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with something really simple, like two varaibles holding a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They hold different values, so when I change the value for one of the variable, then obviously the other **doesn't** get affected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# change value of x\n",
    "x = 30\n",
    "\n",
    "# show both values\n",
    "print('x={}, y={}'.format(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now what if we **set y equal to x, and then change the value of x**? Try to guess before we run the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "\n",
    "# set y to be the same as x\n",
    "y = x\n",
    "\n",
    "# show both values\n",
    "print('BEFORE: x={}, y={}'.format(x, y))\n",
    "\n",
    "# now change x\n",
    "x = 30\n",
    "\n",
    "# show both values\n",
    "print('AFTER: x={}, y={}'.format(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did that match what you expect?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sharing data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a list with a few elements in it, assigned to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['apple', 'orange', 'banana', 'grapefruit']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's assign the list into a new variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fruits = fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, now the variable `my_fruits` holds a list with four items in it. **Now what would happen if we modify the original list?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add another fruit\n",
    "fruits.append('kiwi')\n",
    "\n",
    "# variable `fruits` should now contain 5 items\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking the `my_fruits` list..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the list `my_fruits` now contains the new fruit as well!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discussion: Deeper dive into variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutable vs Immutable objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two kinds of structured data or **objects** you have encountered thus far are lists and dictionaries, and they were **mutable** - that is, the content of the object can be changed after its creation. We will come back and pay much closer attention to this point when we study functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples - Immutable lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have some better insights into mutable vs immutable objects, there is one more structured data or object class that I want to cover: `tuples`. Tuples is just like a list, except that **it cannot be modified after its creation**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (1, 2, 3)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can index and slice a tuple, just like in lists, but you cannot perform any mutating operations such as element assignment or deletion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0] # OK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:2] # OK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0] = 3 # NOT OK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del x[1] # NOT OK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may be wondering what's the point of the tuple. We will revisit tuples in some detail when we study functions. Till then, just remember that tuple is an immutable cousin of lists!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controlling the flow of your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far everything we have been writing had a very predictable **flow** - every line of code gets executed from top to bottom, without any jumps or repeats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While you can achieve a lot with such simple code, one of the greatest strengths of computer program lies in its ability to:\n",
    "\n",
    "* change behavior based on conditions and external information\n",
    "* repeat same (or similar) procedure multiple times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making your code more interactive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we move on, let's learn to be more interactive with our code. Namely, we want our code to respond to our inputs. We can easily do this using `input` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"Hello! What's your name? \")\n",
    "\n",
    "print(\"Nice to meet you, {}!\".format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you see what just happened? The `input` function causes your code to stop, prompting the user of your code to enter in some response. We can then store the response into a variable, and do some work with it. Here, we have printed out a nice personalized greeting!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can talk a bit more with your computer, let's learn how to have **computer make decisions**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a script that asks for a number, and then prints the number **squared**.\n",
    "\n",
    "Hint: `input` always returns a string, so you would have to convert its type before doing math!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional execution with if's"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to know if a number is divisible by 3. Specifically, say we store a number in a variable called `x`, and we want our code to print out a message **if** `x` is divisible by 3. A **pseudocode** could look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 19 # holds a number\n",
    "\n",
    "# if x is divisible by 3\n",
    "print('{} is divisible by 3!'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously we don't want the `print` statement to run if `x` is **not** divisible by 3. Hence, we want to **conditionally execute** a statement (e.g. the `print` statement here). This is precisely what `if` control flow is for!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An `if` statement would look like the following\n",
    "\n",
    "```python\n",
    "if expression:\n",
    "    # code here gets executed if expression evaluates to True\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code is still not complete. We need to pass into `if` an **expression** that would evaluate to either **True** or **False** - a **Boolean value**. We can get a Boolean value by using **Boolean lieterals** like `True` and `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print('This will be printed!')\n",
    "    \n",
    "if False:\n",
    "    print('This will never be printed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And yes! Boolean or `bool` is yet another simple data types in Python!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More interestingly, you can give rise to Boolean values by using one of many **Boolean expressions** that evaluates to `True` or `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Equality\n",
    "print(5 == 5)\n",
    "\n",
    "print(5 == 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Not equal\n",
    "print(5 != 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inequality\n",
    "print(12 >= 10)\n",
    "\n",
    "print(3 < -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using one of these in an `if` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "# check if x is 0\n",
    "if x == 0:\n",
    "    print('x is 0!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now armed with this knowledge, let's see if we can write a code for the divisible by 3 problem. We want to write an expression **that evaluates to True if `x` is divisible by 3**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to think of divisibility is to check for the remainder of the division. In Python, you can use the `modulus` (`%`) operator to find out the remainder of an integer division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "18 % 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "30 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you now complete the code for divisible by 3 problem?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete the code below:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 21 # holds a number\n",
    "\n",
    "# if x is divisible by 3\n",
    "    print('{} is divisible by 3!'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if...else..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if you wanted to perform one action when the `if` condition was `True` but perform a different action if it was `False`, just like a toggle switch? This is precisely what `if...else...` is for! Try to guess what the code below would do **before you run the code**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = int(input('Enter a number: '))\n",
    "\n",
    "if number > 1000:\n",
    "    print(\"That's a pretty big number!\")\n",
    "else:\n",
    "    print(\"That's a reasonable number!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if...elif...else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have just seen 1-out of-2 decision, but what if we wanted to go bigger, taking 1-out of-N decision? Naively, you can chain together multiple `if...else...`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print different messages for a number is negative, 0, positive\n",
    "\n",
    "# get a number\n",
    "number = int(input('Enter a number: '))\n",
    "\n",
    "if number < 0:\n",
    "    print('Your number is negative!')\n",
    "else:\n",
    "    if number == 0:\n",
    "        print('Your number is 0!')\n",
    "    else:\n",
    "        print('Your number is positive!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although this definitely works, you could imagine the code structure becoming increasingly nested and harder to read the more conditions you add. Thankfully, Python provides us with an alternative syntax to combine `else` with another `if`, giving rise an equivalent code snippet below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print different messages for a number is negative, 0, positive\n",
    "\n",
    "# get a number\n",
    "number = int(input('Enter a number: '))\n",
    "\n",
    "if number < 0:\n",
    "    print('Your number is negative!')\n",
    "elif number == 0:\n",
    "    print('Your number is 0!')\n",
    "else:\n",
    "    print('Your number is positive!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the `if...` block inside `else` was combined into `elif` block, allowing you to keep a flat code structure. You can use arbitrary many `elif`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print different messages for number 0, 1, 2, 3, and otherwise\n",
    "\n",
    "# get a number\n",
    "number = int(input('Enter a number: '))\n",
    "\n",
    "if number == 0:\n",
    "    print('Your number is zero')\n",
    "elif number == 1:\n",
    "    print('Your number is one')\n",
    "elif number == 2:\n",
    "    print('Your number is two')\n",
    "elif number == 3:\n",
    "    print('Your number is three')\n",
    "else:\n",
    "    print(\"I'm not too sure about your number...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully now you can see why if...elif...else control flows are commonly referred to as branching control flow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can actually combine multiple (simple or complex) Boolean expressions to form more complex Boolean expression, allowing the computer to make more sophisticated decisions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any computer programmer should become very familiar with three essential boolean operations: `and`, `or`, and `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x and y` operation have the following Truth table:\n",
    "\n",
    "|   x   |   y   | x and y |\n",
    "|:-----:|:-----:|:-------:|\n",
    "|  True |  True |   True  |\n",
    "|  True | False |  False  |\n",
    "| False |  True |  False  |\n",
    "| False | False |  False  |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "username = input('Enter your username: ')\n",
    "password = input('Enter your password: ')\n",
    "\n",
    "if username == 'Edgar' and password == 'mypassword':\n",
    "    print('Correct password. Welcome!')\n",
    "else:\n",
    "    print('Wrong username and/or password!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x or y` operation have the following Truth table:\n",
    "\n",
    "|   x   |   y   | x or y |\n",
    "|:-----:|:-----:|:-------:|\n",
    "|  True |  True |   True  |\n",
    "|  True | False |  True   |\n",
    "| False |  True |  True   |\n",
    "| False | False |  False  |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = int(input('Enter a number: '))\n",
    "\n",
    "if number < 0 or number > 0:\n",
    "    print('Your number is either positive or negative!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`not x` simply inverts the Boolean value of `x`:\n",
    "\n",
    "|   x   |  not x |\n",
    "|:-----:|:-----:|\n",
    "|  True |  False | \n",
    "|  False | True | \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input('Enter your name: ')\n",
    "\n",
    "if not name == 'Edgar':\n",
    "    print('You are not the instructor!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Membership check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with structured data like lists and dictionaries, you would often want to know if an item can be found in the data structure. You can use `in` operator to get a Boolean answer!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Tom', 'Sam', 'Paul']\n",
    "\n",
    "print('Tom' in names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with a dictionary, you would have to specify whether you want to search in the **keys** or **values**. You can grab a list of keys or values by calling the `keys` or `values` method on the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mapping = {\n",
    "    'a': 0,\n",
    "    'b': 3,\n",
    "    'd': 10\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'a' in mapping.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0 in mapping.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that if you are checking for membership in keys, you can directly ask for membership on the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'f' in mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Armed with this knowledge, let's try to improve our earlier password checking code. In the last version, only one person could logon to the system. This time, let us hold a mapping of usernames and passwords in a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "passwords = {\n",
    "    'Edgar': 'mypassword',\n",
    "    'John': '10141984',\n",
    "    'Andreas': '12345678'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we ask for username and password, we want to check two things:\n",
    "\n",
    "* Is it a valid username? (How shall we check for that?)\n",
    "* If it is a valid username, does the password match?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete the following login script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "passwords = {\n",
    "    'Edgar': 'mypassword',\n",
    "    'John': '10141984',\n",
    "    'Andreas': '12345678'\n",
    "}\n",
    "\n",
    "username = input('Enter your username: ')\n",
    "password = input('Enter your password: ')\n",
    "\n",
    "if #condition:\n",
    "    print('Correct password. Welcome!')\n",
    "else:\n",
    "    print('Wrong username and/or password!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops and Repetitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have seen how to do branching in your code, it's time to do loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Need for looping most commonly occurs in the context of **a list traversal** - that is, visiting each and every element of a list, one at a time. In Python, you can visit a list through the `for x in list:` loop control flow. Let's start simple by printing all elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['dog', 'cats', 'donkey', 'sheep', 'koala', 'kangaroo', 'catfish', 'dingo']\n",
    "\n",
    "for x in animals:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was quite simple, wasn't it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make it more interesting by printing only the name of animals starting with character `d`. To do that, I get to tell you that **you can index and slice a string** just like you do for a list to access individual characters!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Edgar Walker'\n",
    "\n",
    "# prints out first character\n",
    "print(name[0])\n",
    "\n",
    "# prints out the last 7 characters\n",
    "print(name[-5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print only animals starting with character `'d'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['dog', 'cats', 'donkey', 'sheep', 'koara', 'kangaroo', 'catfish', 'dingo']\n",
    "\n",
    "for x in animals:\n",
    "    if #check:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traverse through tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the close similarity between lists and tuples, it should come as no surprise that you can traverse or **iterate** through tuples just like lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ('a', 'b', 'c', 'd')\n",
    "\n",
    "print('Content of the tuples')\n",
    "\n",
    "for c in x:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counting up numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say we now want to print from 0 to 9, each number on a line. You can do this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for n in numbers:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although this works, this is very cumbersome with a lot of typing, and also just don't scale with larger numbers. Instead, you can use Python `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in z:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range()` function returns a \"range\" data type that represents a range of numbers, by default starting at 0 and counting up to **but not including** the number you pass into `range`. You can control the start, stop and even step by passing in more numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range from 5 (inclusive) to 11 (exclusive)\n",
    "for x in range(5, 11):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visit all numbers from 0 to 20, with stepsize of 2\n",
    "for x in range(0, 20, 2):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data types or **objects** like lists, tuples, and range that you can step through with the `for ... in ` control flow are known as **iterable** objects. We will encounter a lot of iterables throughout the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterable unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you have an iterable objects, you can **unpack** the iterables, and assign their content to multiple variables all in a single step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, we can take a list with three elements, and distribute the values into three variables in an single assignment operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "\n",
    "a, b, c = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enumerating list items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you iterate through an iterable object, you would often want to know the index of the item you are at. For example, say you want to print the items of a list next to the index in the list.\n",
    "\n",
    "Combining for loop, `range` and `len` of a list, you could achieve it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ('a', 'b', 'c', 'd')\n",
    "\n",
    "for i in range(len(x)):\n",
    "    print(i, x[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is a perfectly valid solution, you can achieve this more elegantly by using `enumerate` function. `enumerate` takes in an iterable and then returns yet another iterable object that returns pair of **index** and **value** from the original iterable object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ('a', 'b', 'c', 'd')\n",
    "\n",
    "for i, v in enumerate(x):\n",
    "    print(i, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does this really work? You can get a sense of how this works by taking a closer look at what `enumerate(x)` returns. However, looking at it directly is not too enlightening."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "enumerate(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can convert most iterable object into an equivalent list by doing **type conversion** into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(enumerate(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can see that `enumerate(x)` is essentially equivalent to a **list of tuples**. Let's now iterate through this simply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in list(enumerate(x)):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might have expected, this visits each **tuple** in the list. When an element of `enumerate(x)` is visited, the returned tuple can be **unpacked** and assigned into two variables instead, hence giving:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, v in list(enumerate(x)):\n",
    "    print(i)\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating through a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may wish to visit every key value pair of a dictionary, and there are many ways of doing this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get an iterable object over the dictionary's keys with `keys()` method we encountered earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary to iterate through\n",
    "temperatures = {\n",
    "    'Houston': 95,\n",
    "    'Chicago': 82,\n",
    "    'Tokyo': 76,\n",
    "    'Trondheim': 50,\n",
    "    'Seattle': 69\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in temperatures.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in temperatures.keys():\n",
    "    print('{} had temperature {}F'.format(k, temperatures[k]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, dictionary provides more convenient way of iterating through the pair via its `items` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that `.items()` essentially returns a list of tuples, where each tuple is a pairing of the key and its value. We can therefore iterate through this list, and unpack each tuple at every iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in temperatures.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus we could rewrite the ealier code as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in temperatures.items():\n",
    "    print('{} had temperature {}F'.format(key, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could probably guess that you can also iterate only through the values of dictionary using `values()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in temperatures.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting it all together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have now already leaned enough Python to get some cool things done. Let's now take what we have seen and learned to solve some interesting challenges!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operating on sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print first *n* square numbers - starting at 1 and ending at *n*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data aggregation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find sum of all values in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vals = [1, 4, 7, 12, 9, 8]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vals = [1, 4, 7, 12, 9, 8]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vals = [1, 4, 7, 12, 9, 8]\n",
    "\n",
    "    \n",
    "print('Variance is {}'.format(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum of all integers between 1 and n, where n is given by the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "\n",
    "n = # get an integer from the user\n",
    "\n",
    "# put logic here\n",
    "\n",
    "print('Sum from 1...{} = {}'.format(n, total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional data aggregation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find sum of all even elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vals = [1, 4, 7, 12, 9, 8]\n",
    "\n",
    "total = 0\n",
    "\n",
    "# logic goes here\n",
    "\n",
    "print('Total of even elements is {}'.format(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering list content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new list that only contains words starting with `'a'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = ['apple', 'banana', 'python', 'acid', 'potato', 'atom']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tallying results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a list of \"yes\"s and \"no\"s, count up the total number of yes and no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tally = {\n",
    "    \"yes\": 0,\n",
    "    \"no\": 0\n",
    "}\n",
    "votes = ['yes', 'yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'yes', 'no', 'yes', 'no', 'no', 'yes']\n",
    "\n",
    "# tally up results here\n",
    "    \n",
    "print(\"There are {} Yes's and {} No's\".format(tally['yes'], tally['no']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering dictionary content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a dictionary, prepare a dictionary that only contains specified entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = {\n",
    "    'Houston': 95,\n",
    "    'Chicago': 82,\n",
    "    'Tokyo': 76,\n",
    "    'Trondheim': 50,\n",
    "    'Seattle': 69\n",
    "}\n",
    "\n",
    "keep = ['Houston', 'Tokyo']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As your data gets more and more complicated, you will encounter **nested data structures** where an element of a data structure is yet another data structure. Here we look at **list of lists**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List of lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a list of lists, print out every elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = [[1, 3, 4], [5, 7], [10, 12, 13, 221]]\n",
    "\n",
    "# visit every element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a list of lists, return one big list that is a concatenated version of the element list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = [[1, 3, 4], [5, 7], [10, 12, 13, 221]]\n",
    "\n",
    "# give flat list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each **inner list**, compute and printout the sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = [[1, 3, 4], [5, 7], [10, 12, 13, 221]]\n",
    "\n",
    "# compute sum for each inner list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of printint out the sum, store the sums into another list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = [[1, 3, 4], [5, 7], [10, 12, 13, 221]]\n",
    "\n",
    "# store sum for each inner list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework Assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print only positive numbers in the list. Be sure to test out your code with various lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [10, -5, -120, 0, 30, 3000, -0.00000001]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a script that prompts the user for 3 numbers, and then print out the sum, average and maximum of the 3 numbers.\n",
    "\n",
    "**Extra challenge**: Can you do it for 5 numbers? What about 10 numbers? How much work does it take for you to change the number of inputs your code takes in and work on?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a script that works on a list and returns a new list that only contains unique elements. For example, if you are given a list `['apple', 'banana', 'apple', 'orange', 'apple', 'grape', 'orange']` you should return a new list like `['apple', 'banana', 'orange', 'grape']`, although the order of items may be different.\n",
    "\n",
    "**Hint**: remember `in` for list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['apple', 'banana', 'apple', 'orange', 'apple', 'grape', 'orange']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a list of words forming a poem, count up the number of occurrences of every word in the list.\n",
    "\n",
    "**Hint 1**: Look back to the yes/no tallying example\n",
    "\n",
    "**Hint 2**: Think about how to handle the very first occurence of the word - you will have to initialize the entry!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "poem = [\n",
    "    'take','this','kiss','upon','the','brow','and','in','parting','from',\n",
    "    'you','now','thus','much','let','me','avow','you','are','not',\n",
    "    'wrong','who','deem','that','my','days','have','been','a','dream;',\n",
    "    'yet','if','hope','has','flown','away','in','a','night','or',\n",
    "    'in','a','day','in','a','vision','or','in','none','is',\n",
    "    'it','therefore','the','less','gone','all','that','we','see','or',\n",
    "    'seem','is','but','a','dream','within','a','dream','I','stand',\n",
    "    'amid','the','roar','of','a','surf','tormented','shore','and','I',\n",
    "    'hold','within','my','hand','grains','of','the','golden','sand','how',\n",
    "    'few','yet','how','they','creep','through','my','fingers','to','the',\n",
    "    'deep','while','I','weep','while','I','weep','o','god','can',\n",
    "    'I','not','grasp','them','with','a','tighter','clasp','o','god',\n",
    "    'can','I','not','save','one','from','the','pitiless','wave','is',\n",
    "    'all','that','we','see','or','seem','but','a','dream','within',\n",
    "    'a','dream'\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra challenge: maximum value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A classic computer science challenge is to find the maximum value in a list. Can you come up with a code to find the maximum value of an arbitrary list of numbers?\n",
    "\n",
    "If you have never seen this, this can be quite challenging!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}