Lab 0.1 Python 101.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a great general-purpose programming language on its own, but with the help of a few popular libraries (numpy, scipy, matplotlib) it becomes a powerful environment for scientific computing.\n",
    "\n",
    "We expect that many of you will have some experience with Python and numpy; for the rest of you, this section will serve as a quick crash course both on the Python programming language and on the use of Python for scientific computing.\n",
    "\n",
    "Some of you may have previous knowledge in Matlab, in which case we also recommend the numpy for Matlab users page (https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we will cover:\n",
    "\n",
    "* Basic Python: Basic data types (Containers, Lists, Dictionaries, Sets, Tuples), Functions, Classes\n",
    "* Numpy: Arrays, Array indexing, Datatypes, Array math, Broadcasting\n",
    "* Matplotlib: Plotting, Subplots, Images\n",
    "* IPython: Creating notebooks, Typical workflows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers and floats work as you would expect from other languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x + 1)   # Addition;\n",
    "print(x - 1)   # Subtraction;\n",
    "print(x * 2)   # Multiplication;\n",
    "print(x ** 2)  # Exponentiation;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x / 2)   # Floating point division\n",
    "print(x // 2)  # Integer division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x += 1    # x = x + 1 = 4\n",
    "print(x)  # Prints 4\n",
    "x *= 2    # x = x * 2 = 8\n",
    "print(x)  # Prints 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 2.5\n",
    "print(type(y)) # Prints <class 'float'>\n",
    "print(y, y + 1, y * 2, y ** 2) # Prints 2.5 3.5 5.0 6.25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t, f = True, False\n",
    "print(type(t)) # Prints <class 'bool'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t and f) # Logical AND;\n",
    "print(t or f)  # Logical OR;\n",
    "print(not t)   # Logical NOT;\n",
    "print(t != f)  # Logical XOR;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello = 'hello'   # String literals can use single quotes\n",
    "world = \"world\"   # or double quotes; it does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hello, len(hello))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hw = hello + ' ' + world  # String concatenation\n",
    "print(hw)  # prints \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hw12 = '{} {} {}'.format(hello, world, 12)  # string formatting\n",
    "print(hw12)  # prints \"hello world 12\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hw20 = \"%s %s %d\" %(hello, world, 20)\n",
    "print(hw20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String objects have a bunch of useful methods; for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello World\"\n",
    "print(s.upper())                # Convert a string to uppercase; prints \"HELLO WORLD\"\n",
    "print(s.lower())                # Convert a string to uppercase; prints \"hello world\"\n",
    "print(s.replace('l', '<ell>'))  # Replace all instances of one substring with another;\n",
    "                                # prints \"He<ell><ell>o Wor<ell>d\"\n",
    "print('  world\\n \\t'.strip())   # Strip leading and trailing whitespace; prints \"world\"\n",
    "print(s.split(' '))             # Splits the string into a list of tokens on ' '. prints ['Hello', 'World']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a list of all string methods in the [documentation](https://docs.python.org/2/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Containers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python includes several built-in container types: lists, dictionaries, sets, and tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [3, 1, 2]   # Create a list\n",
    "print(xs)\n",
    "print(xs[0])     # Indexing starts from zero. prints 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs[2] = 'foo'    # Lists can contain elements of different types\n",
    "print(xs)\n",
    "\n",
    "# DON'T DO THIS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs.append('bar') # Add a new element to the end of the list\n",
    "print(xs)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zip takes 2 lists and returns a list of tuples containing elements of both lists. It's useful for iterating 2 lists simultaneously"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = ['a', 'b', 'c']\n",
    "\n",
    "print(list(zip(x, y)))  # prints [(1, 'a'), (2, 'b'), (3, 'c')]\n",
    "print(list(zip(y, x)))  # prints [('a', 1), ('b', 2), ('c', 3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, you can find all the details about lists in the [documentation](https://docs.python.org/2/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "xs = [1, 2, 3, 4, 5, 6]\n",
    "# Take slices of lists\n",
    "# Last index is not inclusive\n",
    "print(xs[2:5])     # prints [3, 4, 5]\n",
    "\n",
    "# Slice to the end\n",
    "# If last index is not specified slices to the last element\n",
    "print(xs[3:])      # prints [4, 5, 6]\n",
    "\n",
    "# Slice from the beginning\n",
    "# If first index is not specified slices from first element\n",
    "print(xs[:4])      # prints [1, 2, 3, 4]\n",
    "\n",
    "# Negative indexing\n",
    "# Last element is -1\n",
    "print(xs[-1])      # prints 6\n",
    "\n",
    "# Second to last element is -2\n",
    "# Remember last index is not inclusive\n",
    "print(xs[2:-2])    #prints [3, 4]\n",
    "\n",
    "# Step slices\n",
    "# Take a slice of step 2 from second element to the second to last not inclusive\n",
    "print(xs[1:-2:2])  # prints [2, 4]\n",
    "\n",
    "# Reverse list\n",
    "print(xs[::-1])    # prints [6, 5, 4, 3, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can loop over the elements of a list like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for a in animals:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want access to the index of each element within the body of a loop, use the built-in `enumerate` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#{}: {}'.format(idx, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A \"classic\" for loop should look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for i in range(len(animals)):\n",
    "    print(animals[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List comprehensions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A frequent programming operation is transforming all elements in a list. As a simple example, consider the following code that computes square numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [1, 2, 3, 4, 5, 6]\n",
    "squares = []\n",
    "for x in xs:\n",
    "    squares.append(x ** 2)\n",
    "print(squares)  # prints [1, 4, 9, 16, 25, 36]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A more concise way to do this is using a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [i ** 2 for i in xs]  \n",
    "print(squares)  # prints [1, 4, 9, 16, 25, 36]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions can also contain conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even_squares = [x ** 2 for x in xs if x % 2 == 0]\n",
    "print(even_squares)  # prints [4, 16, 36]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. \n",
    "Good generic type for storing data. \n",
    "Lookup is fast.\n",
    "\n",
    "You can use it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {}\n",
    "\n",
    "x['Hello'] = 'World'\n",
    "\n",
    "print(x['Hello'])  # Prints World"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the keys and the values in the dictionary like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = {\n",
    "    '0': 'zero', \n",
    "    '1': 'one',\n",
    "    '2': 'two',\n",
    "    '3': 'three',\n",
    "    '4': 'four',\n",
    "    '5': 'five',\n",
    "    '6': 'six',\n",
    "    '7': 'seven',\n",
    "    '8': 'eight',\n",
    "    '9': 'nine',\n",
    "    '10': 'ten'\n",
    "}\n",
    "\n",
    "# The keys (indexes) as a list\n",
    "print(y.keys())  # prints ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10']\n",
    "\n",
    "# The values as a list\n",
    "print(y.values())  # prints ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']\n",
    "\n",
    "# The items as a list\n",
    "print(y.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if an element is in y keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('0' in y)\n",
    "print(0 in y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterate elements in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PRO TIP: You can't assume the elements will be in order\n",
    "# If you need ordered elements use collections.OrderedDict (or lists)\n",
    "for k, v in y.items():\n",
    "    print(\"Key: {}\\t Value: {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary comprehensions: These are similar to list comprehensions, and allow you to easily construct/transform dictionaries. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint  # for pretty printing\n",
    "z =  {k: v.upper() for k, v in y.items()}\n",
    "pprint.pprint(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are defined using the def keyword.\n",
    "\n",
    "\n",
    "A typical function declaration is def f(p1, p2, p3 ..., k1=v1, k2=v2, ...)\n",
    "where p1, p2 ... are positional (required) arguments \n",
    "and k1, k2 ... are keyword (optional) arguments with default values v1, v2, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_num_to_list(xs, num=2):\n",
    "    return [x + num for x in xs]\n",
    "\n",
    "print(add_num_to_list([1, 2, 3]))\n",
    "print(add_num_to_list([1, 2, 3], num=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    f0, f1 = 0, 1\n",
    "    for _ in range(n):\n",
    "        f0, f1 = f1, f0 + f1\n",
    "    return f0\n",
    "\n",
    "print(fibonacci(9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    res = 1\n",
    "    if n == 0 or n == 1:\n",
    "        return res\n",
    "    else:\n",
    "        for i in range(2, n + 1):\n",
    "            res *= i\n",
    "        return res\n",
    "\n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax for defining classes in Python is straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Greeter(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False):\n",
    "        s = ('Hello, {}'.format(self.name))\n",
    "        if loud:\n",
    "            s = s.upper()\n",
    "        print(s)\n",
    "\n",
    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance is also simple. Child class inherits methods and attributes from parent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LoudBob(Greeter):\n",
    "    def __init__(self):\n",
    "        # Call parent constructor\n",
    "        super(LoudBob, self).__init__('Bob')\n",
    "    \n",
    "    # Override parent method. Notice we change the method signature\n",
    "    def greet(self):\n",
    "        # Call parent method\n",
    "        super(LoudBob, self).greet(loud=True)\n",
    "        \n",
    "bob = LoudBob()\n",
    "bob.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Caveats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is dynamically typed and interpreted. So you can compare apples to oranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = 'Hello World'\n",
    "\n",
    "print(x == y)  # evaluates False instead of throwing an exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is wrong with the following function? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_to_pow(xs, n=2):\n",
    "    for i in range(len(xs)):\n",
    "        xs[i] = xs[i] ** n\n",
    "    return xs\n",
    "\n",
    "x = [1, 2, 3]\n",
    "y = list_to_pow(x, n=3)\n",
    "print(\"input is: {}\".format(x))\n",
    "print(\"output is: {}\".format(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fix the previous function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert code in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_to_pow(xs, n=2):\n",
    "    x_out = xs.copy() # Alternatively: x_out = xs[:] OR x_out = list(xs)\n",
    "    for i in range(len(xs)):\n",
    "        x_out[i] = xs[i] ** n\n",
    "    return x_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = list_to_pow(x, n=3)\n",
    "print(\"input is: {}\".format(x))\n",
    "print(\"output is: {}\".format(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes two lists of equal length  as input adds them element by element.\n",
    "The result should be a list containing the element-wise sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert code in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_lists(xs, ys):\n",
    "    # Assert checks the condition given and throws an Exception if False\n",
    "    assert(len(xs) == len(ys))\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = add_lists([1, 2, 3], [10, 10, 10])\n",
    "print(\"{}\".format(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(add_lists([1, 2], [1, 2, 3]))  # Should throw AssertionError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes a string as input and counts how many times each word occurs.\n",
    "Input is a string and output is a dictionary with the words as keys and the counts as values\n",
    "\n",
    "Hint: Use .lower() and .split(), .strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert code in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def strip_punctuation(s):\n",
    "    s = ' '.join(s.split('\\n'))\n",
    "    return ''.join(c for c in s if c not in '?-.,:;')\n",
    "\n",
    "def wordcount(s):\n",
    "    s = strip_punctuation(s)\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"\"\"\n",
    "'Tis sweet and commendable in your nature, Hamlet,\n",
    "To give these mourning duties to your father;\n",
    "But you must know, your father lost a father,\n",
    "That father lost, lost his, and the survivor bound\n",
    "In filial obligation, for some term\n",
    "To do obsequious sorrow. But to persevere\n",
    "In obstinate condolement is a course\n",
    "Of impious stubbornness. 'Tis unmanly grief,\n",
    "It shows a will most incorrect to heaven,\n",
    "A heart unfortified, a mind impatient,\n",
    "An understanding simple and unschool'd;\n",
    "For what we know must be, and is as common\n",
    "As any the most vulgar thing to sense,\n",
    "Why should we in our peevish opposition\n",
    "Take it to heart? Fie, 'tis a fault to heaven,\n",
    "A fault against the dead, a fault to nature,\n",
    "To reason most absurd, whose common theme\n",
    "Is death of fathers, and who still hath cried,\n",
    "From the first corse till he that died today,\n",
    "This must be so. We pray you throw to earth\n",
    "This unprevailing woe, and think of us\n",
    "As of a father; for let the world take note\n",
    "You are the most immediate to our throne,\n",
    "And with no less nobility of love\n",
    "Than that which dearest father bears his son\n",
    "Do I impart toward you. For your intent\n",
    "In going back to school in Wittenberg,\n",
    "It is most retrograde to our desire:\n",
    "And we beseech you bend you to remain\n",
    "Here in the cheer and comfort of our eye,\n",
    "Our chiefest courtier, cousin, and our son.\n",
    "\"\"\"\n",
    "\n",
    "import pprint\n",
    "\n",
    "pprint.pprint(wordcount(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading\n",
    "\n",
    "1. https://docs.python.org/3/tutorial/  \n",
    "2. Learn Python the Hard Way (book)"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}