All of Regular Expressions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# My concise Regular Expression practices\n",
    "### Some theory from Dan Jurafsky's NLP course on Coursera\n",
    "**Goal of Regular Expressions (aka regex)**: It's the most basic tool for text processing.<br>\n",
    "**Usage examples**: Dealing with different formats of a word (singular/plural, starting with upper/lower case letter, or any combination of these).<br>\n",
    "**Disjunction** `[]`:The simplest tool in regex. Meaning _any letter inside square brackets_ <br>\n",
    "**Ranges** `[0-9], [a-z], [A-Z]`: Used to avoid annoying and long expressions. <br>\n",
    "* Example: All alphabetical characters: `[A-Za-z]`\n",
    "* Example: Space and exclamation mark: `[ !]`\n",
    "\n",
    "**Negation (caret sign)**: `^` Used when we don’t want a set of characters (everything except those characters). <br> Caret means negation only when first in `[]`, in other cases it just means caret.\n",
    "<br>\\* Searching for only caret: Use `\\^`\n",
    "* Example: Not a capital letter: `[^A-Z]` \n",
    "* Example: Neither ‘S’ nor ‘s’: `[^Ss]`\n",
    "* Example: Neither ‘e’ nor ‘^’: `[^e^]`\n",
    "\n",
    "**Pipe (or, `‘|’`) for disjunction**: To perform ‘or’ operation\n",
    "* Example: `a|b|c` = `[abc]`\n",
    "* Example: `[gG]rounhog`\n",
    "* Example: `[Ww]oodchuck`\n",
    "\n",
    "**Special characters**:\n",
    "* `?`: Optional previous character\n",
    " * Example: `colou?r` matches both `colour` and `color`\n",
    "* `*`: Zero or more of previous character\n",
    "* `+`: One or more of previous character\n",
    " * `*` and `+` are called Kleene operators (for Steven C. Kleene)\n",
    " * Example: `oo*h!` = `o+h!`\n",
    "* `.` : Any character\n",
    " * Example: `beg.n` matches with `begin`, `began`, `begun`, `beg3n`, etc.\n",
    "\n",
    "**Anchors (special characters)**:\n",
    "* `^`: Matches the beginning of the line\n",
    "* `$`: Matches the end of the line\n",
    " * Example: `\\.$` matches a period at the end of a line\n",
    " * A period by itself (`.`) means any character. Back-slash period (`\\.`) means a real period.<br>\n",
    "\n",
    "\n",
    "* Example: Find all instances of the word “the” in a text.\n",
    " * Answer: `[^A-Za-z][tT]he[^A-Za-z]`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From SoloLearn\n",
    "This part contains some new materials, and also the implementation of regular expressions in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is regex?** A powerful tool for text manipulation.<br>\n",
    "They are a domain specific language (DSL) that is present as a library in most modern programming languages, not just Python.<br>\n",
    "They are useful for two main tasks:\n",
    "* verifying that strings match a pattern (for instance, that a string has the format of an email address), \n",
    "* performing substitutions in a string (such as changing all American spellings to British ones).\n",
    "\n",
    "Regular expressions in Python can be accessed using the re module, which is part of the standard library.<br>\n",
    "After you've defined a regular expression, the `re.match` function can be used to determine whether it matches at the beginning of a string. If it does, match returns an object representing the match, if not, it returns None.<br>\n",
    "To avoid any confusion while working with regular expressions, we would use raw strings as r\"expression\".Raw strings don't escape anything, which makes the use of regular expressions easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Python regex package\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"spam\"\n",
    "\n",
    "if re.match(pattern, \"spamspamspam\"):\n",
    "   print(\"Match\")\n",
    "else:\n",
    "   print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other functions to match patterns are `re.search`, `re.findall` and `re.finditer`. \n",
    "* The function `re.search` finds a match of a pattern anywhere in the string.\n",
    "* The function `re.findall` returns a list of all substrings that match a pattern.\n",
    "* The function `re.finditer` does the same thing as `re.findall`, except it returns an iterator, rather than a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No match\n",
      "Match\n",
      "['spam', 'spam']\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"spam\"\n",
    "\n",
    "if re.match(pattern, \"eggspamsausagespam\"):\n",
    "   print(\"Match\")\n",
    "else:\n",
    "   print(\"No match\")\n",
    "\n",
    "if re.search(pattern, \"eggspamsausagespam\"):\n",
    "   print(\"Match\")\n",
    "else:\n",
    "   print(\"No match\")\n",
    "    \n",
    "print(re.findall(pattern, \"eggspamsausagespam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regex `search` method returns an object with several methods that give details about it. <br>\n",
    "These methods include `group` which returns the string matched, `start` and `end` which return the start and ending positions of the first match, and `span` which returns the start and end positions of the first match as a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pam\n",
      "4\n",
      "7\n",
      "(4, 7)\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"pam\"\n",
    "\n",
    "match = re.search(pattern, \"eggspamsausage\")\n",
    "if match:\n",
    "   print(match.group())\n",
    "   print(match.start())\n",
    "   print(match.end())\n",
    "   print(match.span())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method `sub` replaces all occurrences of the pattern in string with repl, substituting all occurrences, unless count provided. This method returns the modified string.<br>\n",
    "Syntax:\n",
    "```python\n",
    "re.sub(pattern, repl, string, count=0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Metacharacters** are what make regular expressions more powerful than normal string methods. They allow you to create regular expressions to represent concepts like \"one or more repetitions of a vowel\". <br>\n",
    "The existence of metacharacters poses a problem if you want to create a regex that matches a literal metacharacter, such as `$`. You can do this by escaping the metacharacters by putting a backslash (`\\`) in front of them. However, this can cause problems, since backslashes also have an escaping function in normal Python strings. This can mean putting three or four backslashes in a row to do all the escaping. To avoid this, you can use a raw string, which is a normal string with an `r` in front of it.\n",
    "\n",
    "`.`: Matches any character, other than a new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"gr.y\"\n",
    "\n",
    "if re.match(pattern, \"grey\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"gray\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"blue\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`^` and `$`: These match the start and end of a string, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"^gr.y$\"\n",
    "\n",
    "if re.match(pattern, \"grey\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"gray\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"stingray\"):\n",
    "   print(\"Match 3\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The pattern `^gr.y$` means that the string should start with gr, then follow with any character, except a newline,\n",
    "and end with y."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Character classes** provide a way to match only one of a specific set of characters.<br>\n",
    "A character class is created by putting the characters it matches inside square brackets `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"[aeiou]\"\n",
    "\n",
    "if re.search(pattern, \"grey\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.search(pattern, \"qwertyuiop\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.search(pattern, \"rhythm myths\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Character classes can also match ranges of characters. \n",
    "* Example: `[G-P]` matches any uppercase character from G to P.\n",
    "\n",
    "Multiple ranges can be included in one class. For example, [A-Za-z] matches a letter of any case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n"
     ]
    }
   ],
   "source": [
    "#Example:\n",
    "pattern = r\"[A-Z][A-Z][0-9]\"\n",
    "\n",
    "if re.search(pattern, \"LS8\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.search(pattern, \"E3\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.search(pattern, \"1ab\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`^`: Place it at the start of a character class to invert it. This causes it to match any character other than the ones included. Other metacharacters such as `$` and `.`, have no meaning within character classes. The metacharacter ^ has no meaning unless it is the first character in a class. <br>\n",
    "* Example: The pattern `[^A-Z]` excludes uppercase strings.\n",
    "\n",
    "Note that `^` should be inside the brackets to invert the character class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"[^A-Z]\"\n",
    "\n",
    "if re.search(pattern, \"this is all quiet\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.search(pattern, \"AbCdEfG123\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.search(pattern, \"THISISALLSHOUTING\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some more metacharacters are `*`, `+`, `?` and `{}`, which specify numbers of repetitions.<br>\n",
    "`*` means \"zero or more repetitions of the previous thing\". It tries to match as many repetitions as possible. The \"previous thing\" can be a single character, a class, or a group of characters in parentheses. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"egg(spam)*\"\n",
    "\n",
    "if re.match(pattern, \"egg\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"eggspamspamegg\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"spam\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`+` is very similar to `*`, except it means \"**one** or more repetitions\", as opposed to \"**zero** or more repetitions\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"g+\"\n",
    "\n",
    "if re.match(pattern, \"g\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"gggggggggggggg\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"abc\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`?` means \"**zero or one** repetitions\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"ice(-)?cream\"\n",
    "\n",
    "if re.match(pattern, \"ice-cream\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"icecream\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"sausages\"):\n",
    "   print(\"Match 3\")\n",
    "\n",
    "if re.match(pattern, \"ice--ice\"):\n",
    "   print(\"Match 4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Curly braces (`{}`) can be used to represent the number of repetitions between two numbers.\n",
    "The regex `{x,y}` means \"between x and y  repetitions of something\". \n",
    "Hence `{0,1}` is the same thing as `?`.<br>\n",
    "If the first number is missing, it is taken to be zero. <br>\n",
    "If the second number is missing, it is taken to be infinity. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"9{1,3}$\"\n",
    "\n",
    "if re.match(pattern, \"9\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"999\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"9999\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Groups** <br>\n",
    "A group can be created by surrounding part of a regular expression with parentheses. This means that a group can be given as an argument to metacharacters such as `*` and `?`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"egg(spam)*\"\n",
    "\n",
    "if re.match(pattern, \"egg\"):\n",
    "   print(\"Match 1\")\n",
    "\n",
    "if re.match(pattern, \"eggspamspamspamegg\"):\n",
    "   print(\"Match 2\")\n",
    "\n",
    "if re.match(pattern, \"spam\"):\n",
    "   print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The content of groups in a match can be accessed using the group function. <br>\n",
    "A call of `group(0)` or `group()` returns the whole match. <br>\n",
    "A call of `group(n)`, where n is greater than 0, returns the nth group from the left. <br>\n",
    "The method `groups()` returns all groups up from 1. <br>\n",
    "Groups can be nested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefghi\n",
      "abcdefghi\n",
      "bc\n",
      "de\n",
      "('bc', 'de', 'fgh', 'g')\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"a(bc)(de)(f(g)h)i\"\n",
    "\n",
    "match = re.match(pattern, \"abcdefghijklmnop\")\n",
    "if match:\n",
    "   print(match.group())\n",
    "   print(match.group(0))\n",
    "   print(match.group(1))\n",
    "   print(match.group(2))\n",
    "   print(match.groups())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several kinds of special groups. Two useful ones are named groups and non-capturing groups. <br>\n",
    "Named groups have the format `(?P<name>...)`, where _name_ is the name of the group, and _..._ is the content. They behave exactly the same as normal groups, except they can be accessed by group(name) in addition to its number. <br>\n",
    "Non-capturing groups have the format `(?:...)`. They are not accessible by the group method, so they can be added to an existing regular expression without breaking the numbering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "('abc', 'ghi')\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"(?P<first>abc)(?:def)(ghi)\"\n",
    "\n",
    "match = re.match(pattern, \"abcdefghi\")\n",
    "if match:\n",
    "   print(match.group(\"first\"))\n",
    "   print(match.groups())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`|` is another metacharacter, and means \"or\".\n",
    "* Example: `red|blue` matches either `red` or `blue`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"gr(a|e)y\"\n",
    "\n",
    "match = re.match(pattern, \"gray\")\n",
    "if match:\n",
    "   print (\"Match 1\")\n",
    "\n",
    "match = re.match(pattern, \"grey\")\n",
    "if match:\n",
    "   print (\"Match 2\")    \n",
    "\n",
    "match = re.match(pattern, \"griy\")\n",
    "if match:\n",
    "    print (\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Special Sequences** <br>\n",
    "They are written as a backslash followed by another character. One useful special sequence is a backslash and a number between 1 and 99, e.g., `\\1` or `\\17`. This matches the expression of the group of that number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"(.+) \\1\"\n",
    "\n",
    "match = re.match(pattern, \"word word\")\n",
    "if match:\n",
    "   print (\"Match 1\")\n",
    "\n",
    "match = re.match(pattern, \"?! ?!\")\n",
    "if match:\n",
    "   print (\"Match 2\")    \n",
    "\n",
    "match = re.match(pattern, \"abc cde\")\n",
    "if match:\n",
    "   print (\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note that `(.+) \\1` is not the same as `(.+) (.+)`, because `\\1` refers to the first group's subexpression, which is the matched expression itself, and not the regex pattern."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More useful special sequences are `\\d`, `\\s`, and `\\w`. These match digits, whitespace, and word characters respectively. <br>\n",
    "In ASCII mode they are equivalent to `[0-9]`, `[ \\t\\n\\r\\f\\v]`, and `[a-zA-Z0-9_]`.\n",
    "In Unicode mode they match certain other characters, as well. For instance, `\\w` matches letters with accents.\n",
    "Versions of these special sequences with upper case letters - `\\D`, `\\S`, and `\\W` - mean the opposite to the lower-case versions. For instance, `\\D` matches anything that isn't a digit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"(\\D+\\d)\"\n",
    "\n",
    "match = re.match(pattern, \"Hi 999!\")\n",
    "\n",
    "if match:\n",
    "   print(\"Match 1\")\n",
    "\n",
    "match = re.match(pattern, \"1, 23, 456!\")\n",
    "if match:\n",
    "   print(\"Match 2\")\n",
    "\n",
    "match = re.match(pattern, \" ! $?\")\n",
    "if match:\n",
    "    print(\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `(\\D+\\d)` matches one or more non-digits followed by a digit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additional special sequences are `\\A`, `\\Z`, and `\\b`. <br>\n",
    "The sequences `\\A` and `\\Z` match the beginning and end of a string, respectively. <br>\n",
    "The sequence `\\b` matches the empty string between `\\w` and `\\W` characters, or `\\w` characters and the beginning or end of the string. Informally, it represents the boundary between words.<br>\n",
    "The sequence `\\B` matches the empty string anywhere else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match 1\n",
      "Match 2\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "pattern = r\"\\b(cat)\\b\"\n",
    "\n",
    "match = re.search(pattern, \"The cat sat!\")\n",
    "if match:\n",
    "   print (\"Match 1\")\n",
    "\n",
    "match = re.search(pattern, \"We s>cat<tered?\")\n",
    "if match:\n",
    "   print (\"Match 2\")\n",
    "\n",
    "match = re.search(pattern, \"We scattered.\")\n",
    "if match:\n",
    "   print (\"Match 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\b(cat)\\b` basically matches the word \"cat\" surrounded by word boundaries."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}