7_Pattern_Matching_with_Regular_Expression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phone number found: 415-555-1011\n",
      "Phone number found: 415-555-9999\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "def isPhoneNumber(text):\n",
    "   if len(text) != 12:\n",
    "      return False\n",
    "   for i in range(0, 3):\n",
    "      if not text[i].isdecimal():\n",
    "         return False\n",
    "   if text[3] != '-':\n",
    "      return False\n",
    "   for i in range(4, 7):\n",
    "      if not text[i].isdecimal():\n",
    "         return False\n",
    "   if text[7] != '-':\n",
    "      return False\n",
    "   for i in range(8, 12):\n",
    "      if not text[i].isdecimal():\n",
    "         return False\n",
    "   return True\n",
    "\n",
    "message = 'Call me at 415-555-1011 tomorrow. 415-555-9999 is my office.'\n",
    "for i in range(len(message)):\n",
    "   chunk = message[i:i+12]\n",
    "   if isPhoneNumber(chunk):\n",
    "      print('Phone number found: ' + chunk)\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The email address is vincentprincewill44@gmail.com\n",
      "The email address is vincentprincewill44@yahoo.com\n"
     ]
    }
   ],
   "source": [
    "def isEmail(text):\n",
    "   if '@' not in text:\n",
    "      return False\n",
    "   if '.com' not in text:\n",
    "      return False\n",
    "   return True\n",
    "\n",
    "message = 'You can reach me with; vincentprincewill44@gmail.com or on my yahoo equivalent vincentprincewill44@yahoo.com'\n",
    "sample = message.split()\n",
    "for i in sample:\n",
    "   if isEmail(i):\n",
    "      print(f'The email address is {i}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['vincentprincewill44@gmail.com', 'vincentprincewill44@yahoo.com']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "findEmail = re.compile(r'\\S+@\\S+.com')\n",
    "mo = findEmail.findall(message)\n",
    "mo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['at', '415-555-1011', 'tomorrow.']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "love = 'at 415-555-1011 tomorrow. '\n",
    "love.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phone number found: (415)-555-4242\n"
     ]
    }
   ],
   "source": [
    "# using Regular Expression (Regex)\n",
    "import re\n",
    "phoneNumReg = re.compile(r'\\(\\d{3}\\)-\\d{3}-\\d{4}')\n",
    "mo = phoneNumReg.search('My number is (415)-555-4242.')\n",
    "if mo:\n",
    "   print(f'Phone number found: {mo.group()}')\n",
    "else:\n",
    "   print(\"Phone number: Not found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'While I encourage you to enter the example code into the interactive shell, you should\\nalso make use of web-based regular expression testers, which can show you exactly\\nhow a regex matches a piece of text that you enter. I recommend the tester at http://\\nregexpal.com/.'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''While I encourage you to enter the example code into the interactive shell, you should\n",
    "also make use of web-based regular expression testers, which can show you exactly\n",
    "how a regex matches a piece of text that you enter. I recommend the tester at http://\n",
    "regexpal.com/.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Batman', 'Tina Fey']\n",
      "Batman\n"
     ]
    }
   ],
   "source": [
    "heroRegex = re.compile(r'Batman|Tina Fey')\n",
    "# returns all occurances in a list\n",
    "mo = heroRegex.findall('Batman and Tina Fey')\n",
    "print(mo)\n",
    "# returns the first occurance\n",
    "mo = heroRegex.search('Batman and Tina Fey')\n",
    "print(mo.group())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0906 772 8652\n",
      "[('0811', ' ', '733', ' ', '1652'), ('0906', ' ', '772', ' ', '8652')]\n"
     ]
    }
   ],
   "source": [
    "nIgNumber = re.compile(r\"(\\+234|0)\\d{3}( )?\\d{3}( )?\\d{4}\")\n",
    "sample = nIgNumber.search(\"0906 772 8652\")\n",
    "print(sample.group())\n",
    "nIgNumber = re.compile(r\"(\\+234|0\\d{3})( )?(\\d{3})( )?(\\d{4})\")\n",
    "sample = nIgNumber.findall(\"0811 733 1652 and 0906 772 8652\")\n",
    "print(sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# String '\\w'\n",
    "inbtw = re.compile(r'h(\\w)?n')\n",
    "sample = inbtw.search('hbbn')\n",
    "if sample:\n",
    "   print(sample.group())\n",
    "else:\n",
    "   print(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ILOVESYSADMIN\n",
      "WHATSAY"
     ]
    }
   ],
   "source": [
    "word = 'I realLy hOpe VancouvEr posseSs Yummy Soft vAnilla Dupper Mint Ice Nutella cream'\n",
    "word1 = 'WHAT do you SAY?'\n",
    "# upperAlphbet = re.compile(r'A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z')\n",
    "# or\n",
    "upperAlphbet = re.compile(r'[A-Z]')\n",
    "mo = upperAlphbet.findall(word)\n",
    "for i in mo:\n",
    "   print(i, end='')\n",
    "print()\n",
    "mo = upperAlphbet.findall(word1)\n",
    "for i in mo:\n",
    "   print(i, end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batwoman\n",
      "Batwowowowoman\n",
      "\n",
      "Batman\n",
      "Batwowowowoman\n"
     ]
    }
   ],
   "source": [
    "# ()+ one or more occurance\n",
    "batRegex = re.compile(r'Bat(wo)+man')\n",
    "mo = batRegex.search('The Adventure of Batwoman')\n",
    "print(mo.group())\n",
    "mo = batRegex.search('The Adventure of Batwowowowoman')\n",
    "print(mo.group())\n",
    "print()\n",
    "# ()* zero or more occurance\n",
    "batRegex = re.compile(r'Bat(wo)*man')\n",
    "mo = batRegex.search('The Adventure of Batman')\n",
    "print(mo.group())\n",
    "mo = batRegex.search('The Adventure of Batwowowowoman')\n",
    "print(mo.group())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HaHaHaHaHa\n",
      "HaHaHa\n"
     ]
    }
   ],
   "source": [
    "# Greedy and non-greegy matching\n",
    "# Greedy prioritize the longer occurance\n",
    "greedyHaRegex = re.compile(r'(Ha){3,5}')\n",
    "mo = greedyHaRegex.search('HaHaHaHaHa')\n",
    "print(mo.group())\n",
    "# Non-greedy prioritize the shorter occurance\n",
    "greedyHaRegex = re.compile(r'(Ha){3,5}?')\n",
    "mo = greedyHaRegex.search('HaHaHaHaHa')\n",
    "print(mo.group())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n\\\\d - Any numeric digit from 0 - 9\\n\\\\D - Any character that is not a numeric digit from 0 - 9\\n\\\\w - Any letter, numeric digit, or the underscore character.\\n      (Think of this as matching \"word\" characters)\\n\\\\W - Any character that is not a letter, numeric digit, or the\\n      underscore character\\n\\\\s = Any space, tab, or newline character. (Think of this as \\n      matching \"space\" character)\\n\\\\S - Any character that is not a space, tab, or newline.\\n'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escape characters\n",
    "'''\n",
    "\\d - Any numeric digit from 0 - 9\n",
    "\\D - Any character that is not a numeric digit from 0 - 9\n",
    "\\w - Any letter, numeric digit, or the underscore character.\n",
    "      (Think of this as matching \"word\" characters)\n",
    "\\W - Any character that is not a letter, numeric digit, or the\n",
    "      underscore character\n",
    "\\s = Any space, tab, or newline character. (Think of this as \n",
    "      matching \"space\" character)\n",
    "\\S - Any character that is not a space, tab, or newline.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['R',\n",
       " 'b',\n",
       " 'C',\n",
       " 'p',\n",
       " ' ',\n",
       " 't',\n",
       " 's',\n",
       " ' ',\n",
       " 'b',\n",
       " 'b',\n",
       " 'y',\n",
       " ' ',\n",
       " 'f',\n",
       " 'd',\n",
       " '.',\n",
       " ' ',\n",
       " 'B',\n",
       " 'B',\n",
       " 'Y',\n",
       " ' ',\n",
       " 'F',\n",
       " 'D',\n",
       " '.']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matchNum = re.compile(r'[0-9,]')\n",
    "sample = matchNum.findall('21, 27')\n",
    "sample\n",
    "# In prefixing the carat (^) charater it negates the search\n",
    "vowels = re.compile(r'[^aeiouAEIOU]')\n",
    "vowels.findall('RoboCop eats baby food. BABY FOOD.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nYou can also use the caret symbol (^) at the start of a regex to indicate that\\na match must occur at the beginning of the searched text. Likewise, you can\\nput a dollar sign ($) at the end of the regex to indicate the string must end\\nwith this regex pattern. And you can use the ^ and $ together to indicate\\nthat the entire string must match the regex—that is, it's not enough for a\\nmatch to be made on some subset of the string\\n\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The Caret and Dollar sign\n",
    "'''\n",
    "You can also use the caret symbol (^) at the start of a regex to indicate that\n",
    "a match must occur at the beginning of the searched text. Likewise, you can\n",
    "put a dollar sign ($) at the end of the regex to indicate the string must end\n",
    "with this regex pattern. And you can use the ^ and $ together to indicate\n",
    "that the entire string must match the regex—that is, it's not enough for a\n",
    "match to be made on some subset of the string\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "beginWithHello = re.compile(r'^Hello')\n",
    "mo = beginWithHello.search('Hello world!')\n",
    "print(mo.group())\n",
    "endWithNumber = re.compile(r'\\d+$')\n",
    "mo = endWithNumber.search('Your number is 42')\n",
    "print(mo.group())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cat', 'hat', 'sat', 'lat', 'mat']\n",
      "\n",
      "Al\n",
      "Sweigart\n",
      "\n",
      "<To serve man>\n",
      "<To serve man> for dinner.>\n"
     ]
    }
   ],
   "source": [
    "atRegex = re.compile(r'.at')\n",
    "mo = atRegex.findall('The cat in the hat sat on the flat mat')\n",
    "print(mo)\n",
    "\n",
    "print()\n",
    "\n",
    "nameRegex = re.compile(r'First Name: (.*) Last Name: (.*)')\n",
    "mo = nameRegex.search('First Name: Al Last Name: Sweigart')\n",
    "print(mo.group(1))\n",
    "print(mo.group(2))\n",
    "\n",
    "print()\n",
    "\n",
    "nongreedyRegex = re.compile(r'<.*?>')\n",
    "mo = nongreedyRegex.search('<To serve man> for dinner.>')\n",
    "print(mo.group())\n",
    "\n",
    "greedyRegex = re.compile(r'<.*>')\n",
    "mo = greedyRegex.search('<To serve man> for dinner.>')\n",
    "print(mo.group())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robocop\n",
      "CENSORED gave the secret documents to CENSORED.\n",
      "\n",
      "A**** told C**** that E**** knew B**** was a double agent.\n"
     ]
    }
   ],
   "source": [
    "# Case-Insentitive Matching\n",
    "robocop = re.compile(r'robocop', re.I)\n",
    "mo = robocop.search('Robocop is part man, part machine, all cop')\n",
    "print(mo.group())\n",
    "# Substituting Strings with the sub() Method\n",
    "namesRegex = re.compile(r'Agent \\w+')\n",
    "mo = namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')\n",
    "print(mo)\n",
    "\n",
    "print()\n",
    "\n",
    "# you can type \\1, \\2, \\3, and so on, to mean “Enter the text of group 1, 2, 3, and so on, in the substitution.”\n",
    "agentNamesRegex = re.compile(r'Agent (\\w)\\w*')\n",
    "mo = agentNamesRegex.sub(r'\\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')\n",
    "print(mo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To be continued pg 188"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a077222d77dfe082b8f1dd562ad70e458ac2ab76993a0b248ab0476e32e9e8dd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}