bonus_regex_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python for Biology\n",
    "# Bonus Materials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code Along"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regular Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although we looked at some string manipulation tools in Python that help us look for fixed patterns, regular expressions offer us a lot more flexibility. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember how we used special characters when we learned about string manipulation (e.g. \\n, \\t)? We can put an `r` (stands for raw string literal) in front of a string (outside the quotes) in Python to make sure the string ignores the special characters. We'll need this so that the special characters that regular expressions use don't end up clashing with those that have special meaning for strings. \n",
    "\n",
    "A backslash goes back to being a backslash when we prefix it with `r` and will get stored literally as they appear. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\t\\n\n"
     ]
    }
   ],
   "source": [
    "print(r\"\\t\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The module `re` allows us to use regular expressions in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the search method to look for a pattern in a string using `re.search()`. This will act like it is True or a False to let us know whether it found the pattern in the string. (Really it is returning a match object, but we'll get more into that later).\n",
    "\n",
    "This method takes two arguments, the pattern you want to search for (as a string) and the string you want to search in. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use string characters to find an exact match. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match!\n"
     ]
    }
   ],
   "source": [
    "# not we don't strictly need the raw notation for this pattern string (but this is good practice)\n",
    "sequence = \"python\"\n",
    "pattern = r\"python\"\n",
    "if re.match(pattern, sequence):\n",
    "    print(\"Match!\")\n",
    "else: \n",
    "    print(\"Not a match!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.match()` only matches from the beginning of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not a match!\n"
     ]
    }
   ],
   "source": [
    "sequence = \"python\"\n",
    "pattern = r\"y\"\n",
    "if re.match(pattern, sequence):\n",
    "    print(\"Match!\")\n",
    "else: \n",
    "    print(\"Not a match!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wild Card "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regular expressions use a set of special characters that don't literally match themselves but can be used as flexible search wildcards.\n",
    "\n",
    "Here is a good cheatsheet: https://www.dataquest.io/wp-content/uploads/2019/03/python-regular-expressions-cheat-sheet.pdf\n",
    "\n",
    "For example, `.` can match any single character except a newline character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time let's try out the method `re.search()` which will scan the string for the first instance of that pattern (if it exists). If the pattern exists, it will return something called a **MatchObject**. If not, it will return `None`. \n",
    "\n",
    "If we also tack on the `.group()` it will return the string matched."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"p.thon\", \"python\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\w` will match any single digit, letter, or underscore. If we use the uppercase (`\\W`) it will search for the inverse (any character that is not a digit, letter, or underscore). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"p\\wthon\", \"python\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p&thon'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"p\\Wthon\", \"p&thon\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\s` will match any whitespace character (like a space, newline, or return). \n",
    "\n",
    "`\\S` matches the inverse of this (any character that is not a whitespace character).\n",
    "\n",
    "`\\t` matches tabs.\n",
    "\n",
    "`\\n` matches newlines.\n",
    "\n",
    "`\\r` matches return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'transmitting science'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"transmitting\\sscience\", \"transmitting science\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\d` will match any decimal (0-9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'893-483-3847'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d\", \"phone: 893-483-3847\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`^` (carat) will match a pattern at the start of the string.\n",
    "\n",
    "`$` will match a pattern at the end of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'To'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"^To\", \"To be or not to be\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'be'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"be$\", \"To be or not to be\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we put the pattern in square brackets, we can search for any of those characters. This acts like \"or\" did before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Number: 5'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r'Number: [0-6]', 'Number: 5').group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\b` will match only at the beginning or ending of a word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r'\\b[AEIOU]', 'Alphabet').group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted to search for something that is a special character (literally?) We can use `\\` (backslash) to escape the character and treat it like any other non-special character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' '"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This treats '\\s' as an escape character because it lacks '\\' at the start of '\\s'\n",
    "re.search(r'\\s', ' ').group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\\\s'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This checks for '\\' in the string instead of '\\t' due to the '\\' used \n",
    "re.search(r'\\\\s', '\\s').group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Repetitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to check for more than one instance of the character, we can use characters to indicate that the type of character might repeat instead of repeating the special character.\n",
    "\n",
    "`+` looks for one or more of the characters \n",
    "\n",
    "`*` looks for zero or more of the characters\n",
    "\n",
    "(Both of these qualifiers are known as **greedy** because they will match as much of the search string as posisble.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'893-483-3847'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d\", \"phone: 893-483-3847\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'893-483-3847'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"\\d+-\\d+-\\d+\", \"phone: 893-483-3847\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bo'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"bo*\", \"bo boooo boooo booooooooo b\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'booooooooo'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"bo*\", \"booooooooo\").group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"bo*\", \"b\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But sometimes a greedy match is not what we want and we only want to mattch the first instance of the pattern. \n",
    "\n",
    "`*?` matches as little of the text as possible\n",
    "\n",
    "`?` is a greedy qualifier that check for exactly zero or one of the character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"bo*?\", \"booooooooo\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or in cases where we want to check for an exact number of a pattern's repetition, we can indicate that too.\n",
    "\n",
    "`{x}` checks for when it repeats exactly x number of times\n",
    "\n",
    "`{x,}`  checks for when it repeats at least x times or more\n",
    "\n",
    "`{x, y}`  checks for when it repeats at least x times but no more than y times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'893-483-3847'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"\\d{3}-\\d{3,}-\\d{3,4}\", \"phone: 893-483-3847\").group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting Strings with RegEx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In an earlier lesson, we used the `.split()` string method to use delimeters to split strings. We can combine this with the power of regular expressions to customize what we want to split on. The `.split()` method doesn't actually allow us to use regulare expressions, but the `re` module has a `.split` method we can use for this. We will input the pattern as the first argument and the string to be split as the second argument.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '19', '1876, 3', '23', '1856, 2', '23', '1865']\n"
     ]
    }
   ],
   "source": [
    "d = \"2.19.1876, 3-23-1856, 2/23/1865\"\n",
    "dates = re.split(r\"[\\./-]\", d)\n",
    "print(dates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grouping for Multiple Groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pull out parts of a matching text using the group feature. Using `.group()` with a number in the parentheses. We've been using it without a number in the parentheses, which returns the whole matched text. \n",
    "\n",
    "To capture different parts of the text in our pattern, we will surround it with parentheses in the pattern string. Then group(1) will match the first pattern we captured, group(2) will capture the second, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nichole.lynn.bennett@gmail.com\n",
      "nichole.lynn.bennett\n",
      "gmail.com\n"
     ]
    }
   ],
   "source": [
    "email = \"You can reach me at nichole.lynn.bennett@gmail.com\"\n",
    "match = re.search(r'([\\w\\.-]+)@([\\w\\.-]+)', email)\n",
    "if match:\n",
    "  print(match.group()) # The whole matched text\n",
    "  print(match.group(1)) # The username (group 1)\n",
    "  print(match.group(2)) # The host (group 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Match Positions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pull out information about the position of the match using the `.start()` and `.end()` methods. Don't forget that Python starts counting at zero. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number!\n",
      "at position 3\n"
     ]
    }
   ],
   "source": [
    "name = \"aaa9adkien3alsdk389\" \n",
    "m = re.search(r\"[\\d]\", name) \n",
    "\n",
    "if m: \n",
    "    print(\"number!\") \n",
    "    print(\"at position \" + str(m.start()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Multiple Matches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we could only find the first match because `.search()` can only give us one match. If we want to process multiple matches, we can use `re.finditer()`, which will give us a list of match objects we can process using our knowledge of looping. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 found at position 3\n",
      "3 found at position 10\n",
      "3 found at position 16\n",
      "8 found at position 17\n",
      "9 found at position 18\n"
     ]
    }
   ],
   "source": [
    "name = \"aaa9adkien3alsdk389\" \n",
    "matches = re.finditer(r\"[\\d]\", name) \n",
    "for m in matches: \n",
    "    base = m.group() \n",
    "    pos  = m.start() \n",
    "    print(base + \" found at position \" + str(pos))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also return a list of all of the parts of the searched string that match a given pattern using the `re.findall()` module. It will return a list of strings (instead of a match object). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['9', '3', '3', '8', '9']\n"
     ]
    }
   ],
   "source": [
    "name = \"aaa9adkien3alsdk389\" \n",
    "result = re.findall(r\"\\d\", name) \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `re` Module Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.search(pattern, string, flags=0)` find the first location where there is a match, returns a match object if found, `None` if not (anywhere in the string)\n",
    "\n",
    "`re.match(pattern, string, flags=0)` returns a match object if the pattern matches the beginning of the string, else it returns `None` (only at the start of the string)\n",
    "\n",
    "`re.findall(pattern, string, flags=0)` finds all possible matches in the string and returns them as a list of string\n",
    "\n",
    "`re.sub(pattern, repl, string, count=0, flags=0)` returns a new string where the leftmost non-overlapping instance of the pattern is replaced by the string in the `repl` argument. If the pattern is not found, it returns the original string. \n",
    "\n",
    "`re.compile(pattern, flags=0)` will compile a regular expression object. This is useful when you need to use the same regular expression several times in a single program. \n",
    "\n",
    "You can modify any of these methods using the `flags` argument. Some of the flags used are: IGNORECASE, DOTALL, MULTILINE, VERBOSE, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some next steps to look into on your journey with regular expressions (that we won't have to cover today) are lookahead and lookbehind assertions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independent Work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regex tester may come in handy for working through these exercises: https://regex101.com/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shakespeare's Complete Works\n",
    "This file comes from Project Gutenburg. Feel free to browse the site and choose a different book to use (link to the URL for its text file). I have Shakespeare's complete works as a default here for you to use. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import requests\n",
    "shakespeare_url = 'https://www.gutenberg.org/files/100/100-0.txt'\n",
    "book = requests.get(shakespeare_url).text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that answers the following questions:\n",
    "\n",
    "* How many times does the word \"the\" appear in the corpus? \n",
    "\n",
    "* How many times is there a quote (\"\") in the corpus? \n",
    "\n",
    "* How many times does the character \"d\" followed by \"e\" appear? \n",
    "\n",
    "* How many times does the character \"d\" followed by \"e\" appear separated by a single letter? \n",
    "\n",
    "* How many times does the character \"d\" and \"e\" appear in any order? \n",
    "\n",
    "* How many times does a version of the word \"love\" (e.g. \"lovely\", \"lover\", \"love\", \"loving\") show up?\n",
    "\n",
    "* How many words in the corpus end with \"e\"?\n",
    "\n",
    "* How many times are there three or more digits in a row in the text?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub data rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_data_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def preprocess(sentence): \n",
    "    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()\n",
    "processed_book = preprocess(book)\n",
    "print(processed_book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30400"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times does the word \"the\" appear in the corpus?\n",
    "len(re.findall(r'\\bthe\\b', processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times is there a quote (\"\") in the corpus?\n",
    "len(re.findall(r'\\”', processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17927"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times does the character \"d\" followed by \"e\" appear?\n",
    "len(re.findall(r'de', processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6689"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times does the character \"d\" followed by \"e\" appear separated by a single letter?\n",
    "len(re.findall(r\"d[a-z]e\", processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37531\n"
     ]
    }
   ],
   "source": [
    "d_by_e = re.findall(r\"de\", processed_book)\n",
    "e_by_d = re.findall(r\"ed\", processed_book)\n",
    "print(len(d_by_e) + len(e_by_d)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3218"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times does a version of the word \"love\" (e.g. \"lovely\", \"lover\", \"love\", \"loving\") show up?\n",
    "len(re.findall(r'\\blov\\w+', processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "182884"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many words in the corpus end with \"e\"?\n",
    "len(re.findall(r'e\\b', processed_book))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "325"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many times are there three or more digits in a row in the text?\n",
    "len(re.findall(r'\\d{3}', processed_book))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Names\n",
    "Create a program that will reformat a name written in the format \"FirstName LastName\" to \"LastName, FirstName\". \n",
    "\n",
    "**Bonus** Make sure that it can handle \"Jr.\", \"Sr.\" suffixes  or \"Dr.\" prefixes correctly or other cases you can think of (e.g. middle names, hyphenated last names, etc.). Note that it is probably impossible to get regular expressions to identify *any* name, so it's okay to be limited in your approach.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jemison, Mae', 'Franklin, Rosalind', 'Zhenyi, Wang', 'Goodall, Jane', 'Johnson, Katherine']\n"
     ]
    }
   ],
   "source": [
    "names = ['Mae Jemison', 'Rosalind Franklin', 'Wang Zhenyi', 'Jane Goodall', 'Katherine Johnson']\n",
    "\n",
    "lastname_first = []\n",
    "for name in names:\n",
    "    match = re.match(r'^(\\w+)\\s(\\w+)$',name)\n",
    "    if match:\n",
    "        lastname_first.append(match.group(2) + \", \" + match.group(1))\n",
    "    else:\n",
    "        print(\"no match found\")\n",
    "print(lastname_first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jemison, Mae', 'Franklin, Rosalind', 'Zhenyi, Wang', 'Goodall, Jane', 'Johnson, Katherine']\n"
     ]
    }
   ],
   "source": [
    "names = ['Mae Jemison', 'Dr. Rosalind Franklin', 'Wang Zhenyi, Jr.', 'Jane Goodall', 'Dr. Katherine Johnson']\n",
    "\n",
    "lastname_first = []\n",
    "for name in names:\n",
    "    match = re.match(r'^(.+)?([A-Z]\\w+)\\s(\\w+)(.+)?$',name)\n",
    "    if match:\n",
    "        lastname_first.append(match.group(3) + \", \" + match.group(2))\n",
    "    else:\n",
    "        print(\"no match found\")\n",
    "print(lastname_first)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus\n",
    "Want more to do? Check this out: https://regexcrossword.com/\n",
    "\n",
    "And this: https://alf.nu/RegexGolf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}