Chap 2 - Python Crash Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Crash Course in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not a comprehensive Python tutorial but instead is intended to highlight the parts of the language that will be most important to us (some of which are often not the focus of Python tutorials). If you have never used Python before, you probably want to supplement this with some sort of beginner tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Virtual Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a matter of good discipline, you should always work in a virtual environment, and never using the “base” Python installation.\n",
    "\n",
    "To create an (Anaconda) virtual environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a Python 3.6 environment named \"dsfs\"\n",
    "conda create -n dsfs python=3.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source activate dsfs # Activate the env"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Whitespace Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The pound sign marks the start of a comment. Python itself\n",
    "# ignores the comments, but they're helpful for anyone reading the code.\n",
    "for i in [1, 2, 3, 4, 5]:\n",
    "    print(i) # first line in \"for i\" block\n",
    "    for j in [1,2,3,4,5]:\n",
    "        print(j)\n",
    "        print( i+j )\n",
    "    print(i)\n",
    "\n",
    "print(\"Done looping\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whitespace is ignored inside parentheses and brackets, which can be helpful for long-winded computations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20)\n",
    "\n",
    "lists_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "more_list_of_lists = [[1, 2, 3],\n",
    "                     [4, 5, 6],\n",
    "                     [7, 8, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# You can also use a backslash to indicate that a statement continues onto the next line\n",
    "\n",
    "two_plus_three = 2 + \\\n",
    "                3\n",
    "print (two_plus_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certain features of Python are not loaded by default. These include both features that are included as part of the language as well as third-party features that you download yourself. In order to use these features, you’ll need to import the modules that contain them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example\n",
    "\n",
    "import re\n",
    "\n",
    "my_regex = re.compile(\"[0-9]+\", re.I) #re is the module containing functions and constants for working with regular expressions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need a few specific values from a module, you can import them explicitly and use them without qualification:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict, Counter\n",
    "\n",
    "lookup = defaultdict(int)\n",
    "my_counter = Counter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function match at 0x000001BB7B3D1D90>\n"
     ]
    }
   ],
   "source": [
    "# importing the entire contents of a module into your namespace might inadvertently overwrite variables you’ve already defined:\n",
    "\n",
    "match = 10\n",
    "from re import * # uh oh, re has a match function\n",
    "print(match) # \"<function match at 0x10281e6a8>\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A function is a rule for taking zero or more inputs and returning a corresponding output. In Python, we typically define functions using def:\n",
    "\n",
    "Python functions are first-class, which means that we can assign them to variables and pass them into functions just like any other arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    \"\"\"\n",
    "    This is where you put an optional docstring that explains what the\n",
    "    function does. For example, this function multiplies its input by 2.\n",
    "    \"\"\"\n",
    "    return x*2\n",
    "\n",
    "def apply_to_one(f):\n",
    "    \"\"\"Calls the function f with 1 as its argument\"\"\"\n",
    "    return f(1)\n",
    "\n",
    "my_double = double\n",
    "x = apply_to_one(my_double)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# It is also easy to create short anonymous functions, or lambdas:\n",
    "y = apply_to_one(lambda x: x + 4)  # Equals 5\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's Up\n",
      "Hello World, I'm Chris\n"
     ]
    }
   ],
   "source": [
    "# Function parameters can also be given default arguments, which only need to be \n",
    "# specified when you want a value other than the default:\n",
    "\n",
    "def my_print(message  = \"Hello World, I'm Chris\"):\n",
    "    print(message)\n",
    "\n",
    "my_print(\"What's Up\")\n",
    "my_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chris Barsolai\n",
      "Chris Last Name\n",
      "First Name Barso\n"
     ]
    }
   ],
   "source": [
    "def full_name( f_name = \"First Name\", l_name=\"Last Name\"):\n",
    "    return f_name + \" \" + l_name\n",
    "\n",
    "print(full_name(\"Chris\", \"Barsolai\"))\n",
    "print(full_name(\"Chris\"))\n",
    "print(full_name(l_name = \"Barso\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses backslashes to encode special characters. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tab_string=\"\\t\"\n",
    "\n",
    "len(tab_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To create raw strings i.e backlash as backlash\n",
    "\n",
    "not_tab_string = r\"\\t\"\n",
    "len(not_tab_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chris Barsolai\n",
      "Chris Barsolai\n"
     ]
    }
   ],
   "source": [
    "# To combine strings, it can be done in two ways:\n",
    "first = \"Chris\" ; last = \"Barsolai\"\n",
    "\n",
    "full_name_1 = first + \" \" + last\n",
    "full_name_2 = \"{0} {1}\".format(first, last)\n",
    "\n",
    "print(full_name_1)\n",
    "print(full_name_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When something goes wrong, Python raises an exception. Unhandled, exceptions will cause your program to crash. You can handle them using try and except:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot divide by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print (0/0)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Cannot divide by zero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "int_list = [1,2,3]\n",
    "heterogenous_list = [\"word\", 0.1, True]\n",
    "list_of_lists = [int_list, heterogenous_list, []]\n",
    "\n",
    "list_length = len(int_list)\n",
    "list_sum = sum(int_list)\n",
    "\n",
    "print(list_length)\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use square brackets to _slice lists_. The slice i:j means all elements from i (inclusive) to j (not inclusive). If you leave off the start of the slice, you’ll slice from the beginning of the list, and if you leave of the end of the slice, you’ll slice until the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "first_three = x[:3]                # [0,1,2]\n",
    "three_to_end = x[3:]               # [3,4, ..... ,9]\n",
    "one_to_four = x[1:5]               # [1,2,3,4]\n",
    "last_three = x[-3:]                # [7,8,9]\n",
    "without_first_and_last = x[1:-1]   # [1,2 ... 8]\n",
    "copy_of_x = x[:]\n",
    "\n",
    "# You can similarly slice strings and other “sequential” types.\n",
    "# A slice can take a third argument to indicate its stride, which can be negative:\n",
    "\n",
    "every_third = x[::3]               # [0,3,6,9]\n",
    "five_to_three = x[5:2:-1]          # [5,4,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has an in operator to check for list membership:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in [0,1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in [4,7,5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is easy to concatenate lists together. If you want to modify a list in place, you can use extend to add items from another collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]\n",
    "x.extend([4,5,6])\n",
    "\n",
    "# Using list addition\n",
    "y = x + [7,8,9]   # y is [1, 2, 3, 4, 5, 6]; x is unchanged\n",
    "\n",
    "x.append(0)       # x is now [1, 2, 3, 0]\n",
    "y = x[-1]         # equals 0\n",
    "z = len(x)        # equals 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It’s often convenient to unpack lists when you know how many elements they contain:\n",
    "x, y = [1, 2] # now x is 1, y is 2\n",
    "\n",
    "# Although you will get a ValueError if you don’t have the same number of elements on both sides.\n",
    "# A common idiom is to use an underscore for a value you’re going to throw away:\n",
    "\n",
    "_, y = [1, 2] # now y == 2, didn't care about the first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are lists’ immutable cousins. Pretty much anything you can do to a list that doesn’t involve modifying it, you can do to a tuple. You specify a tuple by using parentheses (or nothing) instead of square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot modify a tuple\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2]\n",
    "my_tuple = (1,2)\n",
    "other_tuple = 3,4\n",
    "my_list[1] = 3         # my_list is now [1, 3]\n",
    "\n",
    "try:\n",
    "    my_tuple[1] = 3\n",
    "except TypeError:\n",
    "    print(\"Cannot modify a tuple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_and_product(x,y):\n",
    "    return (x+y), (x*y)\n",
    "\n",
    "sp = sum_and_product(2, 3)       # sp is (5, 6)\n",
    "s, p = sum_and_product(5,10)     # s is 15, p is 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary associates values with keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_dict = {}          # Pythonic\n",
    "empty_dict2 = dict()     # Less pythonic\n",
    "age = {\"Chris\": 25, \"Nevis\": 19}\n",
    "\n",
    "chris_age = age[\"Chris\"]      # Equals 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No age listed\n"
     ]
    }
   ],
   "source": [
    "# But you’ll get a KeyError if you ask for a key that’s not in the dictionary:\n",
    "\n",
    "try:\n",
    "    nel_age = age[\"Nelson\"]\n",
    "except:\n",
    "    print(\"No age listed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can check for the existence of a key using 'in':\n",
    "\n",
    "nevis_has_age = \"Nevis\" in age    # True\n",
    "nel_has_age = \"Nelson\" in age     # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries have a get method that returns a default value (instead of raising an exception) \n",
    "# when you look up a key that’s not in the dictionary:\n",
    "\n",
    "chris_age = age.get(\"Chris\", 0)        # Equals 25\n",
    "nelson_age = age.get(\"Nelson\", 0)      # Equals 0\n",
    "no_ones_age = age.get(\"No One\")        # default is None\n",
    "\n",
    "# You can assign key/value pairs using the same square brackets:\n",
    "\n",
    "age[\"Irene\"] = 25\n",
    "age[\"Gloria\"] = 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "print(age[\"Irene\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can use dictionaries to represent structured data:\n",
    "\n",
    "tweet = {\n",
    "    \"user\": \"chrisbarso\",\n",
    "    \"text\": \"Data Science is Awesome\",\n",
    "    \"retweet_count\": 30,\n",
    "    \"hashtag\": [\"data\", \"ml\", \"datascience\", \"GoogleML\"]\n",
    "}\n",
    "\n",
    "# We can also look at all keys or values:\n",
    "\n",
    "tweet_keys = tweet.keys()        # iterable for the keys\n",
    "tweet_values = tweet.values()    # iterable for the values\n",
    "tweet_items = tweet.items()      # iterable for the (key, value) tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['user', 'text', 'retweet_count', 'hashtag'])\n"
     ]
    }
   ],
   "source": [
    "print(tweet_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"user\" in tweet_keys          # True\n",
    "\"user\" in tweet               # True (Pythonic way of checking for keys)\n",
    "\"chrisbarso\" in tweet_values  # True (slow but the only way to check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] Imagine that you’re trying to count the words in a document. An obvious approach is to create a dictionary in which the keys are words and the values are counts. As you check each word, you can increment its count if it’s already in the dictionary and add it to the dictionary if it’s not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document:\n",
    "    if word in word_counts:\n",
    "        word_counts[word] += 1\n",
    "    else:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[2] You could also use the “forgiveness is better than permission” approach and just handle the exception from trying to look up a missing key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document:\n",
    "    try:\n",
    "        word_counts[word] += 1\n",
    "    except KeyError:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[3] A third approach is to use get, which behaves gracefully for missing keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document:\n",
    "    previous_count = word_counts.get(word, 0)\n",
    "    word_counts[word] = previous_count + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A defaultdict is like a regular dictionary, except that when you try to look up a key it doesn’t contain, it first adds a value for it using a zero-argument function you provided when you created it. In order to use defaultdicts, you have to import them from collections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "word_counts = defaultdict(int)\n",
    "for word in document:\n",
    "    word_counts[word] += 1\n",
    "    \n",
    "\n",
    "# They can also be useful with list or dict, or even your own functions:\n",
    "\n",
    "dd_list = defaultdict(list)                # list() produces an empty list\n",
    "dd_list[2].append(1)                       # now dd_list contains {2: [1]}\n",
    "dd_dict = defaultdict(dict)                # dict() produces an empty dict\n",
    "dd_dict[\"Joel\"][\"City\"] = \"Seattle\"        # {\"Joel\" : {\"City\": Seattle\"}}\n",
    "dd_pair = defaultdict(lambda: [0, 0])\n",
    "dd_pair[2][1] = 1                          # now dd_pair contains {2: [0, 1]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}