02-Deeper into Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diving deeper into Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Password checker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple password checker:"
   ]
  },
  {
   "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": [
    "This works, but only for a single user - how can I extend this? In fact, can't I just use a dictionary of username: password somehow?"
   ]
  },
  {
   "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": [
    "# 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, respectively."
   ]
  },
  {
   "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 1"
   ]
  },
  {
   "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 2"
   ]
  },
  {
   "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": [
    "## 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": [
    "# Couple exercises on loops"
   ]
  },
  {
   "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": [
    "### 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": [
    "# Functions - reusing your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you write more code, you'll come across instances in which you'd want to run what looks like same piece of code again and again just with different inputs. For example, computing the sum of a list has occurred multiple times already."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing out the same set of code in many places creates maintenance issue - if you make a change (e.g. fixed a bug), then you have to go to every instance of the code to change them!\n",
    "\n",
    "Rather, it would be better to write your code in a **reusable** fashion, and use the same code in multiple places. That precisely what functions are for!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting():\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While function without inputs can already be somewhat useful, true power of function comes when you pass it some inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "    print(\"Hello, {}!\".format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting('Edgar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What you pass **into the function** is called the **arguments**. Inside the function, the value that the *caller of the function* passes you is called the **parameter** of the function. So in above, `name` is a parameter of the function, and `\"Edgar\"` is the argument you **called your function with**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function that returns results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even better, you can write a function that **returns** a result at the end. Let's write a function that returns square of a number you pass in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = square(x)\n",
    "\n",
    "print('{}^2 = {}'.format(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can take as many arguments as you like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def product(a, b):\n",
    "    return a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now write a function to return sum of a list:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes in a list as input and returns the sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(x):\n",
    "    # content goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean([4, 5, 6, 7, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Now what would happen if you pass in **an empty list**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default values for parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you want to make something about your function to be **optionally** specified - and if it is not specified, just use the default value. You can do this in Python by giving a parameter **default** value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "    print(\"Hello, {}!\".format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name=\"World\"):\n",
    "    print(\"Hello, {}!\".format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## None value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a good time to introduce a special kind of value that can be used to indicatd **absence** of a value - `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# represents Nothingness\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = None\n",
    "\n",
    "# doesn't show anything\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is typically used to indicate that a value is missing or hasn't been set yet. You would check if a value is None by `is None` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = None\n",
    "\n",
    "if a is None:\n",
    "    print(\"a is not initialized!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check if it is defined, you would use `is not None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 100\n",
    "\n",
    "if a is not None:\n",
    "    print(\"a contains some value!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_messages(names=None):\n",
    "    # if names list given, print personalized message to each\n",
    "    if names is not None:\n",
    "        for name in names:\n",
    "            print('Hello, {}!'.format(name))\n",
    "    else:\n",
    "        print('Hello, World!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_messages()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_messages(['Moku', 'Chabo'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function that modifies mutable objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you pass arguments into a function, you must be aware that the function **could** change the content of mutable objects. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [0, 1, 3, -3, 5]\n",
    "\n",
    "def change_list(values):\n",
    "    values[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "change_list(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-in functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python actually comes with a lot of built-in functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max([-1, 3, 4, 30, 7, -19])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min([-1, 3, 4, 30, 7, -19])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can look at the **documentation** of any function by putting **?** at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documenting your function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact you can document your own function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(x):\n",
    "    \"\"\"\n",
    "    Returns the mean of list x\n",
    "    \"\"\"\n",
    "    total = 0\n",
    "    for v in x:\n",
    "        total += v\n",
    "    avg = total / len(x)\n",
    "    return avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get additional set of functions by **importing** a module. Let's now import a module for some advanced mathematical functions like square roots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sin?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sin(math.pi / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can just import the values/functions you want directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making your own module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are going to practice making your own Python module by placing a couple functions inside, and then importing your module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mymodule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mymodule.countup(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Not so scary introduction to Object Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple (but a bit abstract) example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that we want to represent an information about a person at Company X. For a person, you want to keep track of their first name, last name and the department they work in at company X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = \"John\"\n",
    "last_name = \"Doe\"\n",
    "dept = \"R & D\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You also want to be able to print out an introductory message for a person. We can do this with a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(first_name, last_name, dept):\n",
    "    print(\"Hi, my name is {} {}, and I work in {} department at Company X\".format(first_name, last_name, dept))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting(first_name, last_name, dept)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so far so good!\n",
    "\n",
    "However, what happens if we want to now manage multiple people?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name1 = \"John\"\n",
    "last_name1 = \"Doe\"\n",
    "dept1 = \"R&D\"\n",
    "\n",
    "first_name2 = \"David\"\n",
    "last_name2 = \"Kay\"\n",
    "dept2 = \"Marketing\"\n",
    "\n",
    "first_name3 = \"Kaoru\"\n",
    "last_name3 = \"Suzuki\"\n",
    "dept3 = \"HR\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting(first_name1, last_name1, dept1)\n",
    "greeting(first_name2, last_name2, dept2)\n",
    "greeting(first_name3, last_name3, dept3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok this is already starting to get out of the hand. Another thing to note is that the function `greeting` is really specific to the particular set of data, and doesn't really make much sense to be used outside of this context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, the data (`first_name`, `last_name` and `dept`) and the function (`greeting`) are very tightly coupled with each other, and it would actually make sense if they can be somehow managed together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well that's precisely what `class` is for! Here we are going to define a new **class of objects** called **Person** to represent, well, a person at Company X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self):\n",
    "        self.first_name = None\n",
    "        self.last_name = None\n",
    "        self.dept = None\n",
    "        \n",
    "    def greeting(self):\n",
    "        print(\"Hi, my name is {} {}, and I work in {} department at Company X\".format(self.first_name, self.last_name, self.dept))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before diving deeper into what this does, let's try to use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1 = Person()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This just created a new **instance** or an **object** of type/class `Person`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1.first_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1.last_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1.dept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# person can greet\n",
    "person1.greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# give this person name and department\n",
    "person1.first_name = 'John'\n",
    "person1.last_name = 'Doe'\n",
    "person1.dept = 'R&D'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# call greeting method\n",
    "person1.greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create more instances of Person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person2 = Person()\n",
    "person2.first_name = \"David\"\n",
    "person2.last_name = \"Kay\"\n",
    "person2.dept = \"Marketing\"\n",
    "\n",
    "person3 = Person()\n",
    "person3.first_name = \"Kaoru\"\n",
    "person3.last_name = \"Suzuki\"\n",
    "person3.dept = \"HR\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1.greeting()\n",
    "person2.greeting()\n",
    "person3.greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closer look at class definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self):\n",
    "        self.first_name = None\n",
    "        self.last_name = None\n",
    "        self.dept = None\n",
    "        \n",
    "    def greeting(self):\n",
    "        print(\"Hi, my name is {} {}, and I work in {} department at Company X\".format(self.first_name, self.last_name, self.dept))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__init__` is a special function that gets called when you **instantiate** the class. `__init__` lets you **initialize** your object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The create class instance or **object** hold data in its **properties** (e.g. `first_name`). Objects also has **methods** - functions attached to the object that can work with the object's properties - here `greeting` is a method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact `__init__` is a special kind of a **method** at it is a function defined in a class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All methods receive **self** as the first parameter automatically. **self** points to the instance of the object on which the method was called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now improve `__init__`, so that we can pass in first name, last name and department at the time of the Person instantiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, first_name, last_name, dept):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.dept = dept\n",
    "        \n",
    "    def greeting(self):\n",
    "        print(\"Hi, my name is {} {}, and I work in {} department at Company X\".format(self.first_name, self.last_name, self.dept))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This makes creating a person much cleaner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1 = Person('John', 'Doe', 'R&D')\n",
    "person2 = Person('David', 'Kay', 'Marketing')\n",
    "person3 = Person('Kaoru', 'Suzuki', 'HR')\n",
    "\n",
    "all_people= [person1, person2, person3]\n",
    "\n",
    "for p in all_people:\n",
    "    p.greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A more concrete example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that you are trying to represent some information about an eye tracker for your experiment. Typically an eye tracker will have to be calibrated so that the position of the pupil, measured in x and y rotation in degrees, can be translated into a position on the screen as x and y location in pixels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say that an eye tracker would have two values: x and y scaling to be calibrated. Once calibration is done, the pupil position in degrees can be translated into screen positions in pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scale_x = 33\n",
    "scale_y = 43"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now write a function that takes in a pupil position and returns the pixel location on screen, using the scales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_screen_loc(pupil_x, pupil_y, scale_x, scale_y):\n",
    "    screen_x = pupil_x * scale_x\n",
    "    screen_y = pupil_y * scale_y\n",
    "    return screen_x, screen_y  # this returns the pair as a tuple!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_screen_loc(4, 3, scale_x, scale_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far so good!\n",
    "\n",
    "However, what if you needed to manage three eye trackers, each with its own calibration? You could imagine repeating the above 3 times, giving each slightly different name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Tracker 1\n",
    "scale_x1 = 33\n",
    "scale_y1 = 43\n",
    "\n",
    "## Tracker 2\n",
    "scale_x2 = 48\n",
    "scale_y2 = 49\n",
    "\n",
    "## Tracker 3\n",
    "scale_x3 = 18\n",
    "scale_y3 = 30\n",
    "\n",
    "def get_screen_loc(pupil_x, pupil_y, scale_x, scale_y):\n",
    "    screen_x = pupil_x * scale_x\n",
    "    screen_y = pupil_y * scale_y\n",
    "    return screen_x, screen_y  # this returns the pair as a tuple!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_screen_loc(4, 3, scale_x1, scale_y1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_screen_loc(4, 3, scale_x2, scale_y2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_screen_loc(4, 3, scale_x3, scale_y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Important thing to note here is that there is some very strong relationship between the `scale_x` and `scale_y` values and the function `screen_loc`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make this **coupling between data and functions** explicit by defining a **class**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EyeTracker:\n",
    "    def __init__(self, scale_x, scale_y):\n",
    "        self.scale_x = scale_x\n",
    "        self.scale_y = scale_y\n",
    "        \n",
    "    def get_screen_loc(self, pupil_x, pupil_y):\n",
    "        screen_x = pupil_x * self.scale_x\n",
    "        screen_y = pupil_y * self.scale_y\n",
    "        return screen_x, screen_y  # this returns the pair as a tuple!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have just defined a new **class** of object called **EyeTracker**, which as you can guess, is meant to represent an eye tracker!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We actually make use of this by create a **new object instance** of the class we defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creates a new instance\n",
    "tracker1 = EyeTracker(33, 43)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracker1.get_screen_loc(4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Real utility of this comes about when you start creating more trackers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create another tracker and \"calibrate\" it immediately\n",
    "tracker2 = EyeTracker(48, 49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tracker2.get_screen_loc(4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Everything is an object in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you have learned a bit about classes and objects, I want to disclose a secret: every data that you have encountered in Python were in fact objects!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that they all have **properties** and **methods** that you can access and use!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact data types like strings, lists and dictionaries come with a lot of useful methods, some you have encountered already."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Edgar Walker'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns a copy of string with all characters in lower case\n",
    "name.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['banana', 'apple', 'grapefruit']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# finds the index of the item in the list. If not found, returns -1\n",
    "fruits.index('apple')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For any object, you can find the list of all properties and methods with `dir` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework Assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 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": [
    "## Challenge 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": [
    "## Challenge 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": [
    "## Challenge 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": [
    "## Challenge 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take your answers for Challenge 1 - 4, and turn each of them into a function. Be sure to give each function an appropriate name according to what they do!"
   ]
  }
 ],
 "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
}