Assignment 7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d60a41d7",
   "metadata": {},
   "source": [
    "# 1. What is the name of the feature responsible for generating Regex objects?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3deb4eab",
   "metadata": {},
   "source": [
    "The re.compile() function returns Regex objects. In another words, We can compile a regular expression into a regex object to look for occurrences of the same pattern inside various target strings without rewriting it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e285d913",
   "metadata": {},
   "source": [
    "# 2. Why do raw strings often appear in Regex objects?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bb40f3a",
   "metadata": {},
   "source": [
    "Regular expressions use the backslash character ('\\') to indicate special forms (Metacharacters) or to allow special characters (speical sequences) to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals. Hence, Raw strings are used (e.g. r\"\\n\") so that backslashes do not have to be escaped."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67eaaa3b",
   "metadata": {},
   "source": [
    "# 3. What is the return value of the search() method?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832a0d3f",
   "metadata": {},
   "source": [
    "The search() method returns Match objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c83e259f",
   "metadata": {},
   "source": [
    "# 4. From a Match item, how do you get the actual strings that match the pattern?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6715db52",
   "metadata": {},
   "source": [
    "The group() method returns strings of the matched text."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c023cb16",
   "metadata": {},
   "source": [
    "# 5. In the regex which created from the r&#39;(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)&#39;, what does group zero cover? Group 2? Group 1?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae149bd6",
   "metadata": {},
   "source": [
    "In the Regex r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)' the zero group covers the entire pattern match where as the first group cover (\\d\\d\\d) and the second group cover (\\d\\d\\d-\\d\\d\\d\\d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "69b029a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('123', '456-7891')\n",
      "123-456-7891\n",
      "123\n",
      "456-7891\n"
     ]
    }
   ],
   "source": [
    "# Example Program\n",
    "import re\n",
    "phoneNumRegex = re.compile(r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "mo = phoneNumRegex.search('My number is 123-456-7891.')\n",
    "print(mo.groups()) # Prints all groups in a tuple format\n",
    "print(mo.group()) # Always returns the fully matched string \n",
    "print(mo.group(1)) # Returns the first group\n",
    "print(mo.group(2)) # Returns the second group"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7acf3d1",
   "metadata": {},
   "source": [
    "# 6. In standard expression syntax, parentheses and intervals have distinct meanings. How can you tell a regex that you want it to fit real parentheses and periods?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46844d16",
   "metadata": {},
   "source": [
    "The \\. \\( and \\) escape characters in the raw string passed to re.compile() will match actual parenthesis characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c960b3bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(123) 456-7891\n"
     ]
    }
   ],
   "source": [
    "# Example Program\n",
    "import re\n",
    "phoneNumRegex = re.compile(r'(\\(\\d\\d\\d\\)) (\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "mo = phoneNumRegex.search('My phone number is (123) 456-7891.')\n",
    "print(mo.group())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db8ff876",
   "metadata": {},
   "source": [
    "# 7. The findall() method returns a string list or a list of string tuples. What causes it to return one of the two options?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4185cd6",
   "metadata": {},
   "source": [
    "If the regex has no groups, a list of strings is returned. If the regex has groups, a list of tuples of strings is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6371b3fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('(123)', '456-7891')]\n",
      "['123-456-7891']\n"
     ]
    }
   ],
   "source": [
    "# Example Program\n",
    "import re\n",
    "phoneNumRegex = re.compile(r'(\\(\\d\\d\\d\\)) (\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "mo = phoneNumRegex.findall('My phone number is (123) 456-7891')\n",
    "print(mo)\n",
    "\n",
    "# Example Program\n",
    "import re\n",
    "phoneNumRegex = re.compile(r'\\d{3}-\\d{3}-\\d{4}')\n",
    "mo = phoneNumRegex.findall('My number is 123-456-7891.')\n",
    "print(mo) # Prints all groups in a tuple format"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c797205",
   "metadata": {},
   "source": [
    "# 8. In standard expressions, what does the | character mean?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "328b31c9",
   "metadata": {},
   "source": [
    "The | character signifies matching “either, or” between two groups."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "542c31f3",
   "metadata": {},
   "source": [
    "# 9. In regular expressions, what does ? the character stand for?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fdba4b6",
   "metadata": {},
   "source": [
    "The ? character can either mean “match zero or one of the preceding group” or be used to signify nongreedy matching."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b94f4450",
   "metadata": {},
   "source": [
    "# 10.In regular expressions, what is the difference between the + and * characters?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ad9f92e",
   "metadata": {},
   "source": [
    "In Regular Expressions, * Represents Zero ore more occurances of the preceeding group, whereas + represents one or more occurances of the preceeding group."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c48a35",
   "metadata": {},
   "source": [
    "# 11. What is the difference between {4} and {4,5} in regular expression?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "729acfb7",
   "metadata": {},
   "source": [
    "The {4} matches exactly three instances of the preceding group. The {4,5} matches between three and five instances."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "374f1d07",
   "metadata": {},
   "source": [
    "# 12. What do you mean by the \\d, \\w, and \\s shorthand character classes signify in regular expressions?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bfb9c82",
   "metadata": {},
   "source": [
    "The \\d, \\w, and \\s shorthand character classes match a single digit, word, or space character, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07b68183",
   "metadata": {},
   "source": [
    "# 13. What do means by \\D, \\W, and \\S shorthand character classes signify in regular expressions?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "352098e7",
   "metadata": {},
   "source": [
    "The \\d, \\w, and \\s shorthand character classes match a single digit, word, or space character, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4faa08a",
   "metadata": {},
   "source": [
    "# 14. What is the difference between .* ? and .* ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b4a40f",
   "metadata": {},
   "source": [
    ".* is a Greedy mode, which returns the longest string that meets the condition. Whereas .*? is a non greedy mode which returns the shortest string that meets the condition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b221f58",
   "metadata": {},
   "source": [
    "# 15. What is the syntax for matching both numbers and lowercase letters with a character class?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e06cf4",
   "metadata": {},
   "source": [
    "Either [0-9a-z] or [a-z0-9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "628e6f5d",
   "metadata": {},
   "source": [
    "# 16. What is the procedure for making a normal expression in regax case insensitive?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c6ccba",
   "metadata": {},
   "source": [
    "We can pass re.IGNORECASE as a flag to make a normal expression case insensitive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "090aca06",
   "metadata": {},
   "source": [
    "# 17. What does the . character normally match? What does it match if re.DOTALL is passed as 2nd argument in re.compile()?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffd38a7a",
   "metadata": {},
   "source": [
    "The . character normally matches any character except the newline character. If re.DOTALL is passed as the second argument to re.compile(), then the dot will also match newline characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31e330f8",
   "metadata": {},
   "source": [
    "# 18. If numReg = re.compile(r&#39;\\d+&#39;), what will numRegex.sub(&#39;X&#39;, &#39;11 drummers, 10 pipers, five rings, 4 hen&#39;) return?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4faeeb95",
   "metadata": {},
   "source": [
    "The output will be 'X drummers, X pipers, five rings, X hens'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6043cdec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'X drummers, X pipers, five rings, X hen'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "numReg = re.compile(r'\\d+')\n",
    "numReg.sub('X', '11 drummers, 10 pipers, five rings, 4 hen')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa176a80",
   "metadata": {},
   "source": [
    "# 19. What does passing re.VERBOSE as the 2nd argument to re.compile() allow to do?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50d4d41",
   "metadata": {},
   "source": [
    "re.VERBOSE will allow to add whitespace and comments to string passed to re.compile()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a3b81cec",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Without Using VERBOSE\n",
    "regex_email = re.compile(r'^([a-z0-9_\\.-]+)@([0-9a-z\\.-]+)\\.([a-z\\.]{2, 6})$', re.IGNORECASE)\n",
    " \n",
    "# Using VERBOSE\n",
    "regex_email = re.compile(r\"\"\"\n",
    "                            ^([a-z0-9_\\.-]+)              # local Part like username\n",
    "                            @                             # single @ sign \n",
    "                            ([0-9a-z\\.-]+)                # Domain name like google\n",
    "                            \\.                            # single Dot .\n",
    "                            ([a-z]{2,6})$                 # Top level Domain  like com/in/org\n",
    "                         \"\"\",re.VERBOSE | re.IGNORECASE)   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f909976",
   "metadata": {},
   "source": [
    "# 20. How would you write a regex that match a number with comma for every three digits? It must match the given following:\n",
    "\n",
    "&#39;42&#39;\n",
    "\n",
    "&#39;1,234&#39;\n",
    "\n",
    "&#39;6,368,745&#39;\n",
    "\n",
    "but not the following:\n",
    "\n",
    "&#39;12,34,567&#39; (which has only two digits between the commas)\n",
    "\n",
    "&#39;1234&#39; (which lacks commas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2fcace1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: 42 -> <re.Match object; span=(0, 2), match='42'>\n",
      "Output: 1,234 -> <re.Match object; span=(0, 5), match='1,234'>\n",
      "Output: 6,368,745 -> <re.Match object; span=(0, 9), match='6,368,745'>\n",
      "Output: 12,34,567 -> None\n",
      "Output: 1234 -> None\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "pattern = r'^\\d{1,3}(,\\d{3})*$'\n",
    "pagex = re.compile(pattern)\n",
    "for ele in ['42','1,234', '6,368,745','12,34,567','1234']:\n",
    "    print('Output:',ele, '->', pagex.search(ele))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "878407ce",
   "metadata": {},
   "source": [
    "# 21. How would you write a regex that matches the full name of someone whose last name is Watanabe? You can assume that the first name that comes before it will always be one word that begins with a capital letter. The regex must match the following:\n",
    "\n",
    "&#39;Haruto Watanabe&#39;\n",
    "\n",
    "&#39;Alice Watanabe&#39;\n",
    "\n",
    "&#39;RoboCop Watanabe&#39;\n",
    "\n",
    "but not the following:\n",
    "\n",
    "&#39;haruto Watanabe&#39; (where the first name is not capitalized)\n",
    "\n",
    "&#39;Mr. Watanabe&#39; (where the preceding word has a nonletter character)\n",
    "\n",
    "&#39;Watanabe&#39; (which has no first name)\n",
    "\n",
    "&#39;Haruto watanabe&#39; (where Watanabe is not capitalized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb0046f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  Haruto Watanabe -> <re.Match object; span=(0, 15), match='Haruto Watanabe'>\n",
      "Output:  Alice Watanabe -> <re.Match object; span=(0, 14), match='Alice Watanabe'>\n",
      "Output:  RoboCop Watanabe -> <re.Match object; span=(4, 16), match='Cop Watanabe'>\n",
      "Output:  haruto Watanabe -> None\n",
      "Output:  Mr. Watanabe -> None\n",
      "Output:  Watanabe -> None\n",
      "Output:  Haruto watanabe -> None\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "pattern = r'[A-Z]{1}[a-z]*\\sWatanabe'\n",
    "namex = re.compile(pattern)\n",
    "for name in ['Haruto Watanabe','Alice Watanabe','RoboCop Watanabe','haruto Watanabe','Mr. Watanabe','Watanabe','Haruto watanabe']:\n",
    "    print('Output: ',name,'->',namex.search(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e21a23c1",
   "metadata": {},
   "source": [
    "# 22. How would you write a regex that matches a sentence where the first word is either Alice, Bob,or Carol; the second word is either eats, pets, or throws; the third word is apples, cats, or baseballs; and the sentence ends with a period? This regex should be case-insensitive. It must match the following:\n",
    "\n",
    "&#39;Alice eats apples.&#39;\n",
    "\n",
    "&#39;Bob pets cats.&#39;\n",
    "\n",
    "&#39;Carol throws baseballs.&#39;\n",
    "\n",
    "&#39;Alice throws Apples.&#39;\n",
    "\n",
    "&#39;BOB EATS CATS.&#39;\n",
    "\n",
    "but not the following:\n",
    "\n",
    "&#39;RoboCop eats apples.&#39;\n",
    "\n",
    "&#39;ALICE THROWS FOOTBALLS.&#39;\n",
    "\n",
    "&#39;Carol eats 7 cats.&#39;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fc10bdc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  Alice eats apples. -> <re.Match object; span=(0, 18), match='Alice eats apples.'>\n",
      "Output:  Bob pets cats. -> <re.Match object; span=(0, 14), match='Bob pets cats.'>\n",
      "Output:  Carol throws baseballs. -> <re.Match object; span=(0, 23), match='Carol throws baseballs.'>\n",
      "Output:  Alice throws Apples. -> <re.Match object; span=(0, 20), match='Alice throws Apples.'>\n",
      "Output:  BOB EATS CATS. -> <re.Match object; span=(0, 14), match='BOB EATS CATS.'>\n",
      "Output:  RoboCop eats apples. -> None\n",
      "Output:  ALICE THROWS FOOTBALLS. -> None\n",
      "Output:  Carol eats 7 cats. -> None\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "pattern = r'(Alice|Bob|Carol)\\s(eats|pets|throws)\\s(apples|cats|baseballs)\\.'\n",
    "casex = re.compile(pattern,re.IGNORECASE)\n",
    "for ele in ['Alice eats apples.','Bob pets cats.','Carol throws baseballs.','Alice throws Apples.','BOB EATS CATS.','RoboCop eats apples.'\n",
    ",'ALICE THROWS FOOTBALLS.','Carol eats 7 cats.']:\n",
    "    print('Output: ',ele,'->',casex.search(ele))"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}