Week 11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview\n",
    "\n",
    "* Hour 1\n",
    "  * JSON\n",
    "  * Regular Expressions\n",
    "* Hour 2\n",
    "  * Q&A\n",
    "* Hour 3\n",
    "  * Work Time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# JSON Format\n",
    "\n",
    "Strings can be further arranged, so they can encode more complex information. For example, CSV (Comma-Separated Values) can be used to share spreadsheet data between applications. \n",
    "\n",
    "JSON (Javascript Object Notation) is used to transmit ordered lists (arrays) and name-\n",
    "value pairs (objects). It can be sent in a file or through a web request.\n",
    "\n",
    "## Syntax\n",
    "\n",
    "The syntax for a JSON array is similar to the syntax for a Python list.\n",
    "\n",
    "```\n",
    "[\"Monday\",  6, \"pumpkin\", 3.1415]\n",
    "```\n",
    "\n",
    "The quotation marks around strings are mandatory.\n",
    "\n",
    "The syntax for a JSON objecgts is similar to the syntax for Python dictionaries.\n",
    "````\n",
    "        {\n",
    "           \"latitude_degree\": 43.6617, \n",
    "           \"latitude_direction\": \"N\",\n",
    "           \"longitude_degree\": 79.3950, \n",
    "           \"longitude_direction\": \"W\"\n",
    "        }\n",
    "```\n",
    "\n",
    "Arrays and objects can appear as values within arrays and objects. Here is an example of a complex JSON string, formatted for readability by humans.\n",
    "\n",
    "```\n",
    "[\n",
    " {\n",
    "  \"customer\": {\n",
    "   \"last\": \"Ball\", \n",
    "   \"first\": \"Maldonado\"\n",
    "  }, \n",
    "  \"rating\": 2, \n",
    "  \"specialOrder\": true, \n",
    "  \"tags\": [\n",
    "   \"ullamco\", \n",
    "   \"aute\", \n",
    "   \"mollit\", \n",
    "   \"ex\"\n",
    "  ], \n",
    "  \"greeting\": \"Happy Birthday\", \n",
    "  \"filling\": \"chocolate\", \n",
    "  \"batter\": \"vanilla\", \n",
    "  \"frosting\": \"chocolate\"\n",
    " }\n",
    "]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, it’s a customer dictionary with a nested dictionary for the address and a list of dictionaries for telephone numbers. The formatting is similar to Python.\n",
    "\n",
    "An useful tool when working with JSON is a viewer. JSON that is being transmitted usually has all of the whitespace removed. It makes the total transmission smaller, but difficult for humans to read. It’s common to use a JSON viewer, in your IDE or on a web page. You can find one by Googling.\n",
    "\n",
    "Another common tool is a JSON validator. It checks whether your syntax is correct and helps to\n",
    "localize errors. Sometimes you can use the same tool to view and validate JSON."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing JSON\n",
    "\n",
    "Any Python data structure can be saved as JSON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"latitude_direction\": \"N\", \"longitude_degree\": 79.395, \"latitude_degree\": 43.6617, \"longitude_direction\": \"W\"}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "list1 = [\"Monday\",  6, \"pumpkin\", 3.1415]\n",
    "dict1 = {\n",
    "           \"latitude_degree\": 43.6617, \n",
    "           \"latitude_direction\": \"N\",\n",
    "           \"longitude_degree\": 79.3950, \n",
    "           \"longitude_direction\": \"W\"\n",
    "        }\n",
    "\n",
    "\n",
    "json_encoded = json.dumps(dict1)\n",
    "\n",
    "print json_encoded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading JSON\n",
    "\n",
    "There are Python functions for encoding and decoding JSON into data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Ball\", \n",
      "   \"first\": \"Maldonado\"\n",
      "  }, \n",
      "  \"rating\": 2, \n",
      "  \"specialOrder\": true, \n",
      "  \"tags\": [\n",
      "   \"ullamco\", \n",
      "   \"aute\", \n",
      "   \"mollit\", \n",
      "   \"ex\"\n",
      "  ], \n",
      "  \"greeting\": \"Happy Birthday\", \n",
      "  \"filling\": \"chocolate\", \n",
      "  \"batter\": \"vanilla\", \n",
      "  \"frosting\": \"chocolate\"\n",
      " }, \n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Gallegos\", \n",
      "   \"first\": \"Priscilla\"\n",
      "  }, \n",
      "  \"rating\": 4, \n",
      "  \"specialOrder\": true, \n",
      "  \"tags\": [\n",
      "   \"occaecat\", \n",
      "   \"ullamco\"\n",
      "  ], \n",
      "  \"greeting\": \"Happy Halloween\", \n",
      "  \"filling\": \"cream cheese\", \n",
      "  \"batter\": \"vanilla\", \n",
      "  \"frosting\": \"cream cheese\", \n",
      "  \"_id\": \"544dbb15755bad877f163ce6\"\n",
      " }, \n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Dunlap\", \n",
      "   \"first\": \"Lydia\"\n",
      "  }, \n",
      "  \"rating\": 2, \n",
      "  \"specialOrder\": false, \n",
      "  \"tags\": [\n",
      "   \"reprehenderit\", \n",
      "   \"sunt\", \n",
      "   \"officia\", \n",
      "   \"velit\"\n",
      "  ], \n",
      "  \"greeting\": \"Congratulations\", \n",
      "  \"filling\": \"vanilla\", \n",
      "  \"batter\": \"chocolate\", \n",
      "  \"frosting\": \"vanilla\", \n",
      "  \"_id\": \"544dbb15f27aff34b75532f4\"\n",
      " }, \n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Barron\", \n",
      "   \"first\": \"Adeline\"\n",
      "  }, \n",
      "  \"rating\": 0, \n",
      "  \"specialOrder\": true, \n",
      "  \"tags\": [\n",
      "   \"consectetur\", \n",
      "   \"consectetur\"\n",
      "  ], \n",
      "  \"greeting\": \"Happy Birthday\", \n",
      "  \"filling\": \"cream cheese\", \n",
      "  \"batter\": \"vanilla\", \n",
      "  \"frosting\": \"chocolate\", \n",
      "  \"_id\": \"544dbb1544b3ca9c14246ff6\"\n",
      " }, \n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Meyers\", \n",
      "   \"first\": \"Conley\"\n",
      "  }, \n",
      "  \"rating\": 4, \n",
      "  \"specialOrder\": false, \n",
      "  \"tags\": [\n",
      "   \"cillum\", \n",
      "   \"ea\", \n",
      "   \"duis\"\n",
      "  ], \n",
      "  \"greeting\": \"Congratulations\", \n",
      "  \"filling\": \"custard\", \n",
      "  \"batter\": \"vanilla\", \n",
      "  \"frosting\": \"vanilla\", \n",
      "  \"_id\": \"544dbb15ac1eba4a44347dcf\"\n",
      " }, \n",
      " {\n",
      "  \"customer\": {\n",
      "   \"last\": \"Armstrong\", \n",
      "   \"first\": \"Peterson\"\n",
      "  }, \n",
      "  \"rating\": 1, \n",
      "  \"specialOrder\": true, \n",
      "  \"tags\": [\n",
      "   \"adipisicing\", \n",
      "   \"sit\", \n",
      "   \"mollit\", \n",
      "   \"anim\"\n",
      "  ], \n",
      "  \"greeting\": \"Congratulations\", \n",
      "  \"filling\": \"cream cheese\", \n",
      "  \"batter\": \"carrot\", \n",
      "  \"frosting\": \"chocolate\", \n",
      "  \"_id\": \"544dbb15a350974cd50f19e7\"\n",
      " }\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "with open(\"cake.json\", \"r\") as file_reader:\n",
    "    file_contents = file_reader.read()\n",
    "\n",
    "    \n",
    "json_contents = json.loads(file_contents)\n",
    "\n",
    "# print json_contents\n",
    "print json.dumps(json_contents, indent=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`json_contents` is typically list, a dictionary, or a combination. You already know how to use these. You can use a for to iterate over all the elements in a list. You can use dictionary syntax to access key value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Customer: Ball\n",
      "\tullamco\n",
      "\taute\n",
      "\tmollit\n",
      "\tex\n",
      "Customer: Gallegos\n",
      "\toccaecat\n",
      "\tullamco\n",
      "Customer: Dunlap\n",
      "\treprehenderit\n",
      "\tsunt\n",
      "\tofficia\n",
      "\tvelit\n",
      "Customer: Barron\n",
      "\tconsectetur\n",
      "\tconsectetur\n",
      "Customer: Meyers\n",
      "\tcillum\n",
      "\tea\n",
      "\tduis\n",
      "Customer: Armstrong\n",
      "\tadipisicing\n",
      "\tsit\n",
      "\tmollit\n",
      "\tanim\n"
     ]
    }
   ],
   "source": [
    "for order in json_contents:\n",
    "    print(\"Customer: \" + order['customer']['last'])\n",
    "\n",
    "    for word in order['tags']:\n",
    "        print(\"\\t\" + word)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular Expressions\n",
    "\n",
    "Regular expressions, called regexes for short, are descriptions for a pattern of text. These are useful for validating inputs and formatting.\n",
    "\n",
    "For example, a `\\d` in a regex stands for a digit character—that is, any single numeral 0 to 9. The regex `\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d` is used by Python to match a telephone number as a string of three numbers, a hyphen, three more numbers, another hyphen, and four numbers. Any other string would not match the `\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d` regex.\n",
    "\n",
    "\n",
    "But regular expressions can be much more sophisticated. For example, adding a 3 in curly brackets (`{3}`) after a pattern is like saying, “Match this pattern three times.” So the slightly shorter regex `\\d{3}-\\d{3}-\\d{4}` also matches the correct phone number format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resources\n",
    "\n",
    "* [Chapter 7](https://automatetheboringstuff.com/chapter7/) of \"Automate the Boring Stuff with Python: Practical Programming for Total Beginners\" by Al Sweigart. \n",
    "* [Python Regular Expressions](https://developers.google.com/edu/python/regular-expressions?hl=en) by Google for Education"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating Regex Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "phone_regex = re.compile(r'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matching Regex Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phone number found: 647-970-9425\n"
     ]
    }
   ],
   "source": [
    "phone_match = phone_regex.search('My number is 647-970-9425.')\n",
    "\n",
    "if phone_match is None:\n",
    "    print (\"No match found\")\n",
    "else:\n",
    "    print('Phone number found: ' + phone_match.group())\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Search moves through the string from start to end, stopping at the first match found\n",
    "* All of the pattern must match"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grouping with Parentheses\n",
    "\n",
    "* Parentheses are used to groups parts of expression\n",
    "* Groups can be retrieve parts of the match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "415-555-4242\n",
      "415-555-4242\n",
      "415\n",
      "555-4242\n"
     ]
    }
   ],
   "source": [
    "phone_regex = re.compile(r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "phone_match = phone_regex.search('My number is 415-555-4242.')\n",
    "\n",
    "print phone_match.group()\n",
    "print phone_match.group(0)\n",
    "print phone_match.group(1)\n",
    "print phone_match.group(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('415', '555-4242')\n"
     ]
    }
   ],
   "source": [
    "print phone_match.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "415\n",
      "555-4242\n"
     ]
    }
   ],
   "source": [
    "area_code, main_number = phone_match.groups()\n",
    "\n",
    "print area_code\n",
    "print main_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special Operators\n",
    "\n",
    "* ^ = start, $ = end -- match the start or end of the string\n",
    "* \\ -- inhibit the \"specialness\" of a character. So, for example, use \\. to match a period or \\\\ to match a slash. If you are unsure if a character has special meaning, such as '@', you can put a slash in front of it, \\@, to make sure it is treated just as a character.\n",
    "* | (pipe, on slash key) --alternation, for combinining patterns\n",
    "* ? --optional matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cheese\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cheese_regex = re.compile(r'^Cheese')\n",
    "cheese_match = cheese_regex.search('Cheese Shop sketch')\n",
    "print cheese_match.group()\n",
    "\n",
    "cheese_match = cheese_regex.search('Not much of a Cheese Shop really, is it?')\n",
    "cheese_match == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eric at 0\n",
      "['Eric', 'John', 'Eric']\n"
     ]
    }
   ],
   "source": [
    "monty_regex = re.compile(r\"Terry|Michael|Graham|John|Eric\")\n",
    "monty_match = monty_regex.search(\"Eric Palin, John Cleese, and Eric Idle\")\n",
    "\n",
    "print monty_match.group(), \"at\" , monty_match.start()\n",
    "\n",
    "monty_match = monty_regex.findall(\"Eric Palin, John Cleese, and Eric Idle\")\n",
    "print monty_match\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Parrotcopter'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parrot_regex = re.compile(r'Parrot(man|mobile|copter|bat)')\n",
    "parrot_match = parrot_regex.search('Parrotcopter lost a blade')\n",
    "parrot_match.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parrotman\n",
      "Parrotwoman\n"
     ]
    }
   ],
   "source": [
    "parrot_regex = re.compile(r'Parrot(wo)?man')\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotman')\n",
    "print parrot_match.group()\n",
    "\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotwoman')\n",
    "print parrot_match.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wildcard Characters\n",
    "\n",
    "* . (a period) -- matches any single character except newline '\\n'\n",
    "* \\* (asterisk) -- match zero or more, or optional\n",
    "* \\+ -- match one or more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parrotmobile\n",
      "Parrotwowowoman\n"
     ]
    }
   ],
   "source": [
    "parrot_regex = re.compile(r'Parrot(wo)*man')\n",
    "\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotman')\n",
    "print parrot_matches.group()\n",
    "\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotwowowoman')\n",
    "print parrot_match.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parrotwoman\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parrot_regex = re.compile(r'Parrot(wo)+man')\n",
    "\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotwoman')\n",
    "print parrot_match.group()\n",
    "\n",
    "parrot_match = parrot_regex.search('The Adventures of Parrotman')\n",
    "parrot_match == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Tarquin',\n",
       " \"Fin-tim-lim-bim-whin-bim-lim-bus-stop-F'tang-F'tang-Ole-Biscuitbarrel\")"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Match everything with .*\n",
    "\n",
    "name_regex = re.compile(r'First Name: (.*) Last Name: (.*)')\n",
    "name_match = name_regex.search(\"First Name: Tarquin Last Name: Fin-tim-lim-bim-whin-bim-lim-bus-stop-F'tang-F'tang-Ole-Biscuitbarrel\")\n",
    "name_match.groups()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matching Specific Repetitions\n",
    "\n",
    "Another way of writing `(Ha)(Ha)(Ha)` is `(Ha){3}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HaHaHa'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ha_regex = re.compile(r'(Ha){3}')\n",
    "ha_match = ha_regex.search('HaHaHa')\n",
    "ha_match.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`(Ha){3}` means exactly 3 repetitions\n",
    "`(Ha){,5}` means up to 5 repetitions\n",
    "`(Ha){3,5}` means 3 to 5 repetitions\n",
    "\n",
    "* Python regular matching is greedy by default.\n",
    "  * It takes the first match and makes it as long as possible.\n",
    "  * In ambiguous situations, the longest string possible is matched.\n",
    "* To suppress this use a ? (question mark) after the pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HaHaHaHaHa\n",
      "HaHaHa\n"
     ]
    }
   ],
   "source": [
    "greedy_regex = re.compile(r'(Ha){3,5}')\n",
    "greedy_match = greedy_regex.search('HaHaHaHaHa')\n",
    "print greedy_match.group()\n",
    "\n",
    "nongreedy_regex = re.compile(r'(Ha){3,5}?')\n",
    "nongreedy_match = nongreedy_regex.search('HaHaHaHaHa')\n",
    "print nongreedy_match.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Character Classes\n",
    "\n",
    "Another way of writing `(0|1|2|3|4|5|6|7|8|9)` is `\\d`, which is a shorthand character class.\n",
    "\n",
    "\n",
    "<img src=\"images/character_classes.png\" width=600>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['12 apostles', '11 went', '10 commandments', '9 bright', '8 Gabriel']"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gbs_regex = re.compile(r'\\d+\\s\\w+')\n",
    "gbs_regex.findall(\"12 apostles, 11 went straight to heaven, \\\\\n",
    "                 10 commandments, 9 bright eyed shiners, \\\\\n",
    "                 8 Gabriel angels\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom Character Classes\n",
    "\n",
    "* Use square brackets\n",
    "* Use a caret (^) to negate\n",
    "  * It's on the 6 key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['i', 'i', 'a', 'e', 'a', 'a', 'o', 'E', 'A']"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_regex = re.compile(r'[aeiouAEIOU]')\n",
    "vowel_regex.findall('This is a dead parrot. DEAD.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compilation Flags\n",
    "\n",
    "* DOTALL, S\t--Make . match any character, including newlines\n",
    "* IGNORECASE, I\t--Do case-insensitive matches\n",
    "* LOCALE, L\t--Do a locale-aware match\n",
    "* MULTILINE, M\t--Multi-line matching, affecting ^ and $\n",
    "* VERBOSE, X\t--Enable verbose REs, which can be organized more cleanly and understandably.\n",
    "* UNICODE, U\t--Makes several escapes like \\w, \\b, \\s and \\d dependent on the Unicode character database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['i', 'i', 'a', 'e', 'a', 'a', 'o', 'E', 'A']"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_regex = re.compile(r'[aeiou]', re.I)\n",
    "vowel_regex.findall('This is a dead parrot. DEAD.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise\n",
    "# Joke: What do you call a pig with three eyes? Piiig!\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why don't we use regex instead of string matching all the time?\n",
    "\n",
    "* It's more computationally expensive\n",
    "* If you're doing something simple, stick with strings\n",
    "* If you can't do it any other way, use regex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Answer Game\n",
    "\n",
    "Two roles: person asking the question (Q) and the person answering the question (A)\n",
    "\n",
    "* Q takes question to A\n",
    "* If A can answer it, A keeps the piece of paper\n",
    "* Q takes next question to another A, repeat until all questions are answered\n",
    "\n",
    "If you ask a question 3 times and can't get an answer, bring it to me."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}