regular-expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "25652c41",
   "metadata": {},
   "source": [
    "<img align=\"left\" src=\"https://ithaka-labs.s3.amazonaws.com/static-files/images/tdm/tdmdocs/CC_BY.png\"><br />\n",
    "\n",
    "Created by [Nathan Kelber](http://nkelber.com) under [Creative Commons CC BY License](https://creativecommons.org/licenses/by/4.0/)<br />\n",
    "For questions/comments/improvements, email nathan.kelber@ithaka.org.<br />\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11dd6622",
   "metadata": {},
   "source": [
    "# Regular Expressions\n",
    "\n",
    "**Description:** This lesson introduces the `re` module for analyzing strings with regular expressions. Students will be able to:\n",
    "* Create regular expressions\n",
    "* Create a Regex object with `re.compile()`\n",
    "* Use the `findall()` and `finditer()` methods to return a match object\n",
    "* Return strings of the actual matched text\n",
    "\n",
    "**Use Case:** For Learners (Detailed explanation, not ideal for researchers)\n",
    "\n",
    "**Difficulty:** Beginner\n",
    "\n",
    "**Completion Time:** 90 minutes\n",
    "\n",
    "**Knowledge Required:** \n",
    "* Python Basics ([Start Python Basics I](./python-basics-1.ipynb))\n",
    "\n",
    "**Knowledge Recommended:** None\n",
    "\n",
    "**Data Format:** None\n",
    "\n",
    "**Libraries Used:** [re](https://docs.python.org/3/library/re.html)\n",
    "\n",
    "**Research Pipeline:** None\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "353971d3",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Regular expressions can be used to locate particular characters or sequences of characters in a string. For example, a regular expression could be written to identify phone numbers, email addresses, or particular names. Far beyond simply matching a known string, regular expressions can be written to find complex patterns in a text. They are often useful when the documents being searched are very long. \n",
    "\n",
    "Regular expressions can be used in Python, but also in many other applications such as other programming languages, word processing software (Microsoft Word, Google Docs), or email. Crafting the right regular expression can be very difficult, but can often save hours of labor for many menial tasks. When crafting a regular expression, it can be very helpful to use a tool like [RegExr](https://regexr.com/) that demonstrates how expressions are being matched on a few sample texts as you type them. The tailored expression could then be implemented in a fuller solution with Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7900296",
   "metadata": {},
   "source": [
    "## Practicing with regexr\n",
    "\n",
    "We could practice our regular expressions with Python, but it will be easier, faster, and more interpretable to use a dedicated regular expression tool like [regexr.com](https://regexr.com). We can test our expression on sample data before applying it with Python to a full dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87b55b75",
   "metadata": {},
   "source": [
    "### Metacharacters\n",
    "When executing a search pattern, regular expressions make use of special metacharacters. If you would like to search for one of these characters in your text, you will need to add a backslash (\\) before the character:\n",
    "\n",
    "`. ^ $ * + ? { } [ ] \\ | ( )`\n",
    "\n",
    "Copy and paste all of these expressions into regexr, and then try matching on some of them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18591a02",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Try it! &lt; / &gt; </h3>\n",
    "\n",
    "**Use the dollar sign to add a dollar amount, such as $5.00, to regexr. Can you write a regular expression to match it?**\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d1ca52e",
   "metadata": {},
   "source": [
    "### Character Classes\n",
    "\n",
    "Using the metacharacters in our search pattern will allow us to search particular classes of characters.\n",
    "\n",
    "|Expression|Matches|\n",
    "|---|---|\n",
    "|.| Any character except a new line `\\n` |\n",
    "|\\d| A digit (0-9) |\n",
    "|\\D| Not a digit |\n",
    "|\\w| Word character (a-z, A-Z, 0-9, \\_) |\n",
    "|\\W| Not a word character, not a new line |\n",
    "|\\s| Whitespace (space, tab new line) |\n",
    "|\\S| Not a whitespace |\n",
    "\n",
    "Try each of these with regexr using the following sample text:\n",
    "___\n",
    "\n",
    "```\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "```\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8183c1a",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Coding Challenge! &lt; / &gt; </h3>\n",
    "\n",
    "**Write a regular expression that will match all the phone numbers.**\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa18869",
   "metadata": {},
   "source": [
    "### Anchors\n",
    "\n",
    "An anchor helps search particular text areas, such as string beginnings, string endings, or word boundaries.\n",
    "\n",
    "|Expression|Matches|\n",
    "|---|---|\n",
    "|\\b| Word boundary |\n",
    "|\\B|Not a word boundary |\n",
    "|^| Beginning of string |\n",
    "|$| End of string |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11980aa9",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Try it! &lt; / &gt; </h3>\n",
    "\n",
    "**Use the word boundary `\\b` and not word boundary `\\B` to search for the string `ar`. What is the difference in the results?**\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6454174",
   "metadata": {},
   "source": [
    "### Character sets\n",
    "\n",
    "We can define a set of potential characters to match by putting them in brackets `[]`. \n",
    "\n",
    "|Expression|Matches|\n",
    "|---|---|\n",
    "|[ ]| Characters in brackets |\n",
    "|[^ ]| Characters not in brackets |\n",
    "\n",
    "We can specify exact characters to match:\n",
    "\n",
    "* `[.,-]` Match a period, comma, or dash\n",
    "* `[rs]` Match the lowercase letter r or s\n",
    "* `[^t]` Match any character that is not lowercase t\n",
    "\n",
    "or we can specify a range to match, such as:\n",
    "\n",
    "* `[A-Z]` Match any capital letter, from A to Z\n",
    "* `[A-F]` Match any capital letter, from A to F\n",
    "* `[a-z]` Match any lowercase letter, a to z\n",
    "* `[A-fa-f]` Match any letter, regardless of case from A to F\n",
    "* `[0-3]` Match any number, from 0-3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03ccad5e",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Coding Challenge! &lt; / &gt; </h3>\n",
    "\n",
    "**Write a regular expression that will match the first two phone numbers with dashes or periods but not the final phone numbers with vertical pipes `|`.**\n",
    "\n",
    "```\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "```\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1501879",
   "metadata": {},
   "source": [
    "### Quantifiers\n",
    "\n",
    "Quantifiers let us repeat a character match for some additional number of characters. \n",
    "\n",
    "|Expression|Matches|\n",
    "|---|---|\n",
    "|\\*| 0 or more |\n",
    "|+| 1 or more |\n",
    "|?| 0 or 1 |\n",
    "|{4}| Exact number |\n",
    "|{3,6}| Minimum to maximum range |\n",
    "\n",
    "For example, we could match phone numbers by using:\n",
    "\n",
    "`\\d\\d\\d.\\d\\d\\d.\\d\\d\\d\\d`\n",
    "\n",
    "or we could write this with a quantifier as:\n",
    "\n",
    "`\\d{3}.\\d{3}.\\d{4}`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55d54f93",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Coding Challenge! &lt; / &gt; </h3>\n",
    "\n",
    "**Write a regular expression that will match the full names for each person.**\n",
    "```\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "```\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c415b0a",
   "metadata": {},
   "source": [
    "### Groups\n",
    "\n",
    "We can also use groups to specify sections of a regular expression. This can be handy if we want to return parts of the regular expression in chunks or if we want to specify a set of possibilities for a particular character or set of characters.\n",
    "\n",
    "|Expression|Matches|\n",
    "|---|---|\n",
    "|(A\\|B\\|C)| Capital A or capital B or capital C|\n",
    "\n",
    "In our example above, we could use a group to match a variety of honorifics.\n",
    "\n",
    "`(Mrs|Ms|Mr|Mx|Dr).?` would match a variety honirifics with or without a trailing period."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb59786",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Coding Challenge! &lt; / &gt; </h3>\n",
    "\n",
    "**Write a regular expression that will match the full email addresses.**\n",
    "```\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "```\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "607ac46b",
   "metadata": {},
   "source": [
    "## Using the `re` module\n",
    "\n",
    "The re module offers a great deal of flexibility in working with regular expressions. The workflow for using `re` generally follows this format:\n",
    "\n",
    "1. Import the `re` module and put the text being searched into a string\n",
    "2. Create a Regex object with `re.compile()`\n",
    "3. Pass the string into the compiled Regex object using a method such as:\n",
    "    * `.findall()`\n",
    "    * `.finditer()`\n",
    "4. Return the matches\n",
    "\n",
    "Let's examine these steps in a little more detail.\n",
    "\n",
    "### Import the `re` module and put the search text into a string\n",
    "Import the `re` module with\n",
    "```import re```\n",
    "\n",
    "Create a variable containing the string object to be searched. This could be loaded from a file, such as a text, CSV, or JSON file. (For information on loading data from a file in Python, see [Working with Dataset Files](./working-with-dataset-files.ipynb).)\n",
    "\n",
    "### Create the Regex object with `re.compile()`\n",
    "Compiling the Regex Object establishes the pattern to search for. This is where we add in the regular expression string that we crafted using regexr. Now that we are familiar with the syntax of regular expression strings, it is important to note that they often contain backslash (\\) characters, which can easily be confused with escape characters. For this reason, it is usually a good practice to use a raw string for passing your regular expression into `re.compile()` . A raw string starts with a `r` and skips over any escape characters, such as a new line character `\\n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04caa073",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A demonstration of a regular string with an escape character\n",
    "string = 'Regular string: \\n A new line is created. \\n'\n",
    "print(string)\n",
    "\n",
    "# A demonstration of a raw string where the escape character is ignored\n",
    "raw_string = r'Raw string: \\n The new line escape character is ignored.'\n",
    "print(raw_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7676402",
   "metadata": {},
   "source": [
    "Technically, it is not always necessary to use `re.compile()` to create a Regex Object, but doing so will make your matches go faster. On small documents, the difference is insignificant, but it is a good practice since it will improve the speed of larger searches."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922ec0db",
   "metadata": {},
   "source": [
    "### Pass the string to be searched into the Regex Object\n",
    "\n",
    "The Regex Object in the last step established the pattern for the search. In this step, we pass the string to be searched with the Regex Object pattern.\n",
    "\n",
    "The `re` module includes a variety of methods including:\n",
    "\n",
    "* **.findall()**\n",
    "Return all non-overlapping pattern matches as list of strings or tuples. Will return match groups if the pattern contains groups.\n",
    "* **.finditer()**\n",
    "Return an iterator that yields match objects over all non-overlapping matches.\n",
    "\n",
    "Additional methods are documented in the official [Python re documentation](https://docs.python.org/3/library/re.html). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "093baa78",
   "metadata": {},
   "source": [
    "### Return the Matches\n",
    "\n",
    "The final step is to return the matches for the search. The process and outputs are slightly different for `.findall()` and `.finditer()` methods. There are also additional methods described in the official [Python re documentation](https://docs.python.org/3/library/re.html#)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fe8526d",
   "metadata": {},
   "source": [
    "### A basic example with `.findall()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4e5e62e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the re module\n",
    "import re\n",
    "\n",
    "# The text to search\n",
    "text = '''\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1fb4a1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile a Regex Object\n",
    "# Search for the word quick\n",
    "pattern = re.compile(r'\\d{3}.\\d{3}.\\d{4}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d217facc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the `.findall()` method to gather all the matches into a list\n",
    "matches = pattern.findall(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b1a1ab2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Print the list of matches\n",
    "print(matches)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c1b935b",
   "metadata": {},
   "source": [
    "If the expression passed into `re.compile()` contains no groups, then the output will be a list of matching strings. If the expression does contain groups, the output will be a list of tuples containing only the matching groups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1c40742",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grouping by Honorific, First Name, Last Name\n",
    "pattern = re.compile(r'(M[rs]+\\.?)\\s(\\w+.?)\\s(\\w+)')\n",
    "\n",
    "matches = pattern.findall(text)\n",
    "print(matches)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325cee64",
   "metadata": {},
   "source": [
    "### A basic example with `.finditer()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "490e7af4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile a Regex Object\n",
    "# Search for the word quick\n",
    "pattern = re.compile(r'(M[rs]+\\.?)\\s(\\w+.?)\\s(\\w+)')\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "# into an iterable \"match object\".\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate over the matches and print them out\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b50d613a",
   "metadata": {},
   "source": [
    "When using the `.finditer()` method, each match object contains two important pieces of information:\n",
    "\n",
    "**span**<br />\n",
    "The starting and ending index number for the match within the searched string.\n",
    "\n",
    "**match**<br />\n",
    "The actual characters from the string which fulfilled the Regex Object match. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82d5eb75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verifying the index number slice for the match\n",
    "print(text[154:168])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d7d0060",
   "metadata": {},
   "source": [
    "When using `finditer()`, the groups within a match can be referenced using the `.group()` method.\n",
    "\n",
    "* `.group(0)` returns the full match\n",
    "* `.group(1)` returns the first group\n",
    "* `.group(2)` returns the second group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e6f8d0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile a Regex Object\n",
    "# Search for the word quick\n",
    "pattern = re.compile(r'(M[rs]+\\.?)\\s(\\w+.?)\\s(\\w+)')\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "# into an iterable \"match object\".\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate over the matches and print them out\n",
    "for match in matches:\n",
    "    print(match.group(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96bd25cb",
   "metadata": {},
   "source": [
    "## `re.compile` flags for verbose patterns and ignoring case\n",
    "\n",
    "The `re.compile()` method can accept flags. Two of the most useful are:\n",
    "* `re.VERBOSE` to allow commenting within regular expressions\n",
    "* `re.I` to ignore case when matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fe8c69e",
   "metadata": {},
   "source": [
    "### Verbose mode flag\n",
    "Passing the `re.VERBOSE` flag as a second argument into `re.compile()` will allow you to include comments inside your regular expression similar to a comment in Python. Any text after a `#` will be ignored for the purposes of matching. This can be very useful for documenting and explaining complex regular expressions. \n",
    "\n",
    "Our name matching:\n",
    "\n",
    "`pattern = re.compile(r'M[rs]+\\.?\\s\\w+.?\\s\\w+')`\n",
    "\n",
    "Using a multi-line comment with a triple quote allows for comments that break the expression into chunks while also offering room for explanation.\n",
    "\n",
    "```\n",
    "pattern = re.compile(r'''(\n",
    "    (M[rs]+\\.?)    # Honorific\n",
    "    \\s             # Space\n",
    "    (\\w+.?)        # First name\n",
    "    \\s             # Space\n",
    "    (\\w+)          # Last name\n",
    "    )''', re.VERBOSE)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ef782aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile a Regex Object using the Verbose flag\n",
    "pattern = re.compile(r'''(\n",
    "    (M[rs]+\\.?)    # Honorific\n",
    "    \\s             # Space\n",
    "    (\\w+.?)        # First name\n",
    "    \\s             # Space\n",
    "    (\\w+)          # Last name\n",
    "    )''', re.VERBOSE)\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "# into an iterable object. This is not a list.\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate over the matches and print them out\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed8621e",
   "metadata": {},
   "source": [
    "### Ignore case flag\n",
    "Passing the `re.I` flag as a second argument into `re.compile()` will ignore the case of matches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c61ea368",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the re module\n",
    "import re\n",
    "\n",
    "# The string to search\n",
    "text = 'Constellate CONSTELLATE constellate COnsTeLlate'\n",
    "\n",
    "# Compile a Regex Object\n",
    "# Search for the word constellate\n",
    "pattern = re.compile(r'constellate', re.I)\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate through the matches and print each one\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8424c667",
   "metadata": {},
   "source": [
    "## Research example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320401d1",
   "metadata": {},
   "source": [
    "___\n",
    "<h3 style=\"color:red; display:inline\">Coding Challenge! &lt; / &gt; </h3>\n",
    "\n",
    "**Write a regular expression that will match all the stage directions in a TEI XML file. The stage tags are marked with opening `<stage>` and closing `</stage>` tags.**\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4c948ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download a sample text file\n",
    "# This TEI XML playtext comes from Oxford University and\n",
    "# The Bodleian First Folio (https://firstfolio.bodleian.ox.ac.uk/downloads.html#pdfs)\n",
    "import urllib.request\n",
    "urllib.request.urlretrieve('https://firstfolio.bodleian.ox.ac.uk/download/xml/F-rom.xml', './data/romeoandjuliet.xml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fcbfeda",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the re module\n",
    "import re\n",
    "\n",
    "# A text to search\n",
    "with open('data/romeoandjuliet.xml', 'r') as f:\n",
    "    text = f.read()\n",
    "\n",
    "# Compile a Regex Object\n",
    "# Search for the word quick\n",
    "pattern = re.compile() # insert a regex pattern here to match the stage tags\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate through the matches and print each one\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29421748",
   "metadata": {},
   "source": [
    "___\n",
    "## Lesson Complete\n",
    "\n",
    "Congratulations on completing the Constellate course in regular expressions!\n",
    "\n",
    "\n",
    "### Coding Solutions\n",
    "\n",
    "Here are a few solutions for exercises in this lesson. Many other solutions are possible!\n",
    "\n",
    "```\n",
    "Mr. alex arvison\n",
    "work+arvison0@aol.com\n",
    "323-423-4353\n",
    "\n",
    "Mrs Dara Batha\n",
    "d.batha1@bright.edu\n",
    "102.343.3784\n",
    "\n",
    "Ms T Lamcken\n",
    "tlamcken-2@usda.gov\n",
    "444|343|4387\n",
    "\n",
    "Ms. M. Picardo\n",
    "mpicardo_7@simplemachines.org\n",
    "439|963|6284\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08c2bbbc",
   "metadata": {},
   "source": [
    "#### Match all phone numbers\n",
    "`\\d\\d\\d.\\d\\d\\d.\\d\\d\\d\\d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7e1d8bf",
   "metadata": {},
   "source": [
    "#### Match first two phone numbers\n",
    "`\\d\\d\\d[-.]\\d\\d\\d[-.]\\d\\d\\d\\d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "088d630e",
   "metadata": {},
   "source": [
    "#### Match the full name for every person\n",
    "`M[rs]+\\.?\\s\\w+.?\\s\\w+`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4618f713",
   "metadata": {},
   "source": [
    "#### Match the full email address for every person\n",
    "\n",
    "`[A-Za-z0-9_+-.]+@[A-Za-z0-9_+-.]+\\.(com|edu|gov|org)`\n",
    "\n",
    "`[A-Za-z0-9_+-.]+@[A-Za-z0-9-]+\\.[A-Za-z0-9.-]+`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90352021",
   "metadata": {},
   "source": [
    "#### Stage tags\n",
    "```\n",
    "# Import the re module\n",
    "import re\n",
    "\n",
    "# A text to search\n",
    "with open('data/romeoandjuliet.xml', 'r') as f:\n",
    "    text = f.read()\n",
    "\n",
    "# Compile a Regex Object\n",
    "# Search for the word quick\n",
    "pattern = re.compile(r'<stage.*?>(.*?)</stage>', re.I)\n",
    "\n",
    "# Use the `.finditer()` method to gather all the matches\n",
    "matches = pattern.finditer(text)\n",
    "\n",
    "# Iterate through the matches and print each one\n",
    "for match in matches:\n",
    "    print(match.group(1))\n",
    "```"
   ]
  }
 ],
 "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.10.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}