adv_py_regex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tasks today:\n",
    "1) <b>Importing</b> <br>\n",
    "2) <b>Using Regular Expressions</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) re.compile() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) re.match() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) re.findall() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; d) re.search() <br>\n",
    "3) <b>Sets</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Integer Ranges <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Character Ranges <br>\n",
    "4) <b>Counting Occurences</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) {x} <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) {, x} <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) {?} <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; d) {*} <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; e) {+} <br>\n",
    "5) <b>In-Class Exercise #1</b> <br>\n",
    "6) <b>Escaping Characters</b> <br>\n",
    "7) <b>Grouping</b> <br>\n",
    "8) <b>In-Class Exercise #2</b> <br>\n",
    "9) <b>Opening a File</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) open() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) with open() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) re.match() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; d) re.search() <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; e) Store the String in a Variable <br>\n",
    "10) <b>Regex Project</b> <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing <br>\n",
    "<p>Regular Expressions are universal throughout most programming languages... They are generally imported through the module 're'.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import re\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Regular Expressions <br>\n",
    "<p>Regular expressions give us the ability to search for patterns within text, strings, files, etc. They serve several uses, such as; security measures, searching, filtering, pattern recognition, and more...</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using compile, pre determines the string to be used in regular expression methods\n",
    "pattern = re.compile('abcd')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.match()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 4), match='abcd'>\n",
      "(0, 4)\n"
     ]
    }
   ],
   "source": [
    "match = pattern.match('abcd123')\n",
    "print(match)\n",
    "\n",
    "# Accessing the span of the match\n",
    "\n",
    "print(match.span())\n",
    "\n",
    "# <re.Match object; span=(0, 4), match='abcd'>\n",
    "# (0, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.findall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 'abcd', 'abcd']\n"
     ]
    }
   ],
   "source": [
    "# help(re.findall)\n",
    "finders = pattern.findall('123abcd abcd123 abcd abcabc acb')\n",
    "print(finders)\n",
    "\n",
    "# ['abcd', 'abcd', 'abcd']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.search()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(12, 16), match='abcd'>\n",
      "(12, 16) <class 'tuple'>\n",
      "abcd\n",
      "abcd\n"
     ]
    }
   ],
   "source": [
    "# help(re.search)\n",
    "random_string = '123 123 234 abcd abc'\n",
    "\n",
    "search = pattern.search(random_string)\n",
    "print(search)\n",
    "\n",
    "span = search.span()\n",
    "print(span, type(span))\n",
    "print(random_string[span[0]: span[1]])\n",
    "print(random_string[12:16])\n",
    "\n",
    "#<re.Match object; span=(12, 16), match='abcd'>\n",
    "# (12, 16) <class 'tuple'>\n",
    "# abcd\n",
    "# abcd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets <br>\n",
    "<p>The following cells will allow you to use regular expressions to search for certain values within a range such as numbers 1 through 4.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [a-z] or [A-Z] - any lowercase/uppercase letters from a to z<br/>[^2] - anything that's not 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Integer Ranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(2, 5), match='383'>\n",
      "(2, 5)\n",
      "383\n"
     ]
    }
   ],
   "source": [
    "# 3 digit number meeting the following conditions\n",
    "pattern_int = re.compile('[0-3][7-9][0-4]')\n",
    "my_nums = '67383'\n",
    "\n",
    "\n",
    "# help(re.search) finds the first thing and brings it back\n",
    "\n",
    "random_numbers = pattern_int.search(my_nums)\n",
    "print(random_numbers)\n",
    "span = random_numbers.span()\n",
    "print(span)\n",
    "print(my_nums[span[0]:span[1]])\n",
    "\n",
    "# <re.Match object; span=(2, 5), match='383'>\n",
    "#(2, 5)\n",
    "# 383\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Character Ranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['He', 'Th', 'Mr', 'An']\n"
     ]
    }
   ],
   "source": [
    "char_pattern = re.compile('[A-Z][a-z]')\n",
    "\n",
    "found = char_pattern.findall('Hello There Mr.Anderson')\n",
    "print(found)\n",
    "\n",
    "# ['He', 'Th', 'Mr', 'An']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting Occurences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### {x} - something that occurs {num_of_times}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['An33']\n"
     ]
    }
   ],
   "source": [
    "char_pattern_count = re.compile('[A-Z][a-z][0-3]{2}')\n",
    "\n",
    "found_count = char_pattern_count.findall('Hello Mr. An33derson')\n",
    "print(found_count)\n",
    "\n",
    "# ['An33']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### {x, x} - something that occurs between x and x times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['m', 'm', 'm', 'mm', 'mmmmm', 'mmmmm', 'm']\n"
     ]
    }
   ],
   "source": [
    "random_pattern = re.compile('m{1,5}')\n",
    "\n",
    "random_statement = random_pattern.findall(\"This is an example of a regular expression trying to find one m, more than one mm, or 5 mmmmmmmmmmm's\")                         \n",
    "print(random_statement)\n",
    "\n",
    "# ['m', 'm', 'm', 'mm', 'mmmmm', 'mmmmm', 'm']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ? - something that occurs 0 or 1 time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mrs']\n"
     ]
    }
   ],
   "source": [
    "pattern = re.compile('Mrss?')\n",
    "\n",
    "found_pat = pattern.findall('Hello M ther Mr. Andersonm, Mid how is Mrs.Anderson, and Ms. Anderson?')\n",
    "print(found_pat)\n",
    "\n",
    "# ['Mrs']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### * - something that occurs at least 0 times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['MMMs', 's', 'Ms', 's', 's', 'Ms', 's', 's', 's', 's', 's']\n"
     ]
    }
   ],
   "source": [
    "pattern_m = re.compile('M*s')\n",
    "\n",
    "found_m = pattern_m.findall('MMMs name is Ms. Smith. This is Mssssss')\n",
    "print(found_m)\n",
    "\n",
    "# ['MMMs', 's', 'Ms', 's', 's', 'Ms', 's', 's', 's', 's', 's']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### + - something that occurs at least once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ms', 'MMMMMMMs']\n"
     ]
    }
   ],
   "source": [
    "pattern_again = re.compile('M+s')\n",
    "\n",
    "found_patt = pattern_again.findall('My name is Ms.Smith. This is MMMMMMMsssssss')\n",
    "print(found_patt)\n",
    "\n",
    "# ['Ms', 'MMMMMMMs']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 1: \n",
    "\n",
    "Use a regular expression to find every number in the given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['10909090', '1', '2']\n"
     ]
    }
   ],
   "source": [
    "num_pattern = re.compile('[0-9]+')\n",
    "\n",
    "my_string = \"This string has 10909090 numbers, but it is only 1 string. I hope you solve this 2day.\"\n",
    "# desired Output: ['10909090', '1', '2']\n",
    "\n",
    "found_nums = num_pattern.findall(my_string)\n",
    "print(found_nums)\n",
    "\n",
    "# ['10909090', '1', '2']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escaping Characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### \\w - look for any Unicode character<br/>\\W - look for anything that isnt a Unicode character\n",
    "\n",
    "[History on Unicode](http://unicode.org/standard/WhatIsUnicode.html)\n",
    "\n",
    "[More on Unicode Characters](https://en.wikipedia.org/wiki/List_of_Unicode_characters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🔥\n",
      "['This', 'is', 'a', 'sentence', '1', 'With', 'an', 'exclamation', 'mark', 'at', 'the', 'end']\n",
      "[' ', ' ', ' ', '. ', ' ', ' ', ', ', ' ', ' ', ' ', ' ', '!']\n"
     ]
    }
   ],
   "source": [
    "# unicode for the fire emoji\n",
    "print('\\U0001f525')\n",
    "\n",
    "# any number of unicode characters in a row\n",
    "pattern_1 = re.compile('[\\w]+')\n",
    "# any number of non-unicode characters in a row\n",
    "pattern_2 = re.compile('[\\W]+')\n",
    "\n",
    "found_1 = pattern_1.findall('This is a sentence. With an, exclamation mark at the end!')\n",
    "found_2 = pattern_2.findall('This is a sentence. With an, exclamation mark at the end!')\n",
    "\n",
    "print(found_1)\n",
    "print(found_2)\n",
    "\n",
    "# 🔥\n",
    "# ['This', 'is', 'a', 'sentence', 'With', 'an', 'exclamation', 'mark', 'at', 'the', 'end']\n",
    "# [' ', ' ', ' ', '. ', ' ', ', ', ' ', ' ', ' ', ' ', '!']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### \\d - look for any digit 0-9<br/>\\D - look for anything that isnt a digit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['7th', '27th', '3rd', '1st', '30th']\n"
     ]
    }
   ],
   "source": [
    "pattern_nums = re.compile('\\d{1,2}[a-z]{2}')\n",
    "\n",
    "found_date = pattern_nums.findall('Today is the 7th, in 20 days it will be the 27th. 3rd, 1st, 30th')\n",
    "print(found_date)\n",
    "\n",
    "# ['7th', '27th', '3rd', '1st', '30th']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### \\s - look for any white space<br/>\\S - look for anything that isnt whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', ' ', ' ', ' ', ' ']\n",
      "[' you', ' afraid', ' of', ' the', ' dark']\n"
     ]
    }
   ],
   "source": [
    "pattern_no_space = re.compile('\\s[a-z]+')\n",
    "pattern_space = re.compile('\\s+')\n",
    "found_space = pattern_space.findall('Are you afraid of the dark?')\n",
    "print(found_space)\n",
    "\n",
    "found_dark = pattern_no_space.findall('Are you afraid of the dark?')\n",
    "\n",
    "print(found_dark)\n",
    "\n",
    "# [' ', ' ', ' ', ' ', ' ']\n",
    "# [' you', ' afraid', ' of', ' the', ' dark']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### \\b - look for boundaries or edges of a word<br/>\\B - look for anything that isnt a boundary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['TheCodingTemple']\n"
     ]
    }
   ],
   "source": [
    "pattern_bound = re.compile(r'\\bTheCodingTemple\\b')\n",
    "pattern_bound_none = re.compile(r'\\BTheCodingTemple\\B')\n",
    "\n",
    "no_found_bound = pattern_bound_none.findall(\"TheCodingTemple\")\n",
    "print(no_found_bound)\n",
    "                     \n",
    "found_bound = pattern_bound.findall('TheCodingTemple')\n",
    "print(found_bound)\n",
    "\n",
    "# []\n",
    "# ['TheCodingTemple']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grouping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Max Smith', ' aaron rodgers', ' Sam Darnold', ' Lebron James', ' Michael Jordan', ' Kevin Durant', ' Patrick McCormick']\n",
      "\n",
      "Valid Names:\n",
      "\n",
      "('Max', 'Smith')\n",
      "\"aaron rodgers\" is not a valid name\n",
      "('Sam', 'Darnold')\n",
      "('Lebron', 'James')\n",
      "('Michael', 'Jordan')\n",
      "('Kevin', 'Durant')\n",
      "('Patrick', 'McCormick')\n"
     ]
    }
   ],
   "source": [
    "my_string_again = 'Max Smith, aaron rodgers, Sam Darnold, Lebron James, Michael Jordan, Kevin Durant, Patrick McCormick'\n",
    "\n",
    "# Group of names Regular Expression Compiler\n",
    "pattern_name = re.compile('([A-Z][a-zA-Za-z]+) ([A-Z][A-Za-z]+)')\n",
    "found_names = pattern_name.findall(my_string_again)\n",
    "# print(found_names)\n",
    "\n",
    "# [('Max', 'Smith'), ('Sam', 'Darnold'), ('Lebron', 'James'), ('Michael', 'Jordan'), ('Kevin', 'Durant'), ('Patrick', 'McCormick')]\n",
    "\n",
    "print(my_string_again.split(','))\n",
    "\n",
    "# splits names by commas then checks each to see if it is a match\n",
    "print(\"\\nValid Names:\\n\")\n",
    "for name in my_string_again.split(','):\n",
    "    match = pattern_name.search(name)\n",
    "    \n",
    "    # if something valid there, print it\n",
    "    if match:\n",
    "        print(match.groups(2))\n",
    "    else:\n",
    "        print(f'\"{name.strip()}\" is not a valid name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class Exercise 2:\n",
    "\n",
    "Write a function using regular expressions to find the domain name in the given email addresses (and return None for the invalid email addresses)<br><b>HINT: Use '|' for either or</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "pocohontas1776@gmail.com\n",
      "None\n",
      "yourfavoriteband@g6.org\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Notes:\n",
    "    # No groups needed\n",
    "    # You can also use the $ at the end of your compile expression -- this stops the search\n",
    "    # .com OR .org => com|org\n",
    "# Expected output:\n",
    "    # None\n",
    "    # pocohontas1776@gmail.com\n",
    "    # None\n",
    "    # yourfavoriteband@g6.org\n",
    "    # None\n",
    "\n",
    "import re\n",
    "\n",
    "my_emails = [\"jordanw@codingtemple.orgcom\", \"pocohontas1776@gmail.com\", \"helloworld@aol..com\", \"yourfavoriteband@g6.org\", \"@codingtemple.com\"]\n",
    "\n",
    "# regex expression for valid email\n",
    "regex = '[A-Za-z0-9]+@[A-Za-z0-9]+[.][co][or][mg]$'\n",
    "pattern = re.compile(regex)\n",
    "\n",
    "# if valid email, print\n",
    "for email in my_emails:\n",
    "    match = pattern.match(email)\n",
    "    if match:\n",
    "        print(email)\n",
    "    else:\n",
    "        print('None')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening a File <br>\n",
    "<p>Python gives us a couple ways to import files, below are the two used most often.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### open()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hawkins, Derek\tderek@codingtemple.com\t(555) 555-5555\tTeacher, Coding Temple\t@derekhawkins\n",
      "Zhai, Mo\tmozhai@codingtemple.com\t(555) 555-5554\tTeacher, Coding Temple\n",
      "Johnson, Joe\tjoejohnson@codingtemple.com\t\tJohson, Joe\n",
      "Osterberg, Sven-Erik\tgovernor@norrbotten.co.se\t\tGovernor, Norrbotten\t@sverik\n",
      ", Tim\ttim@killerrabbit.com\t\tEnchanter, Killer Rabbit Cave\n",
      "Butz, Ryan\tryanb@codingtemple.com\t(555) 555-5543\tCEO, Coding Temple\t@ryanbutz\n",
      "Doctor, The\tdoctor+companion@tardis.co.uk\t\tTime Lord, Gallifrey\n",
      "Exampleson, Example\tme@example.com\t555-555-5552\tExample, Example Co.\t@example\n",
      "Pael, Ripal\tripalp@codingtemple.com\t(555) 555-5553\tTeacher, Coding Temple\t@ripalp\n",
      "Vader, Darth\tdarth-vader@empire.gov\t(555) 555-4444\tSith Lord, Galactic Empire\t@darthvader\n",
      "Fernandez de la Vega Sanz, Maria Teresa\tmtfvs@spain.gov\t\tFirst Deputy Prime Minister, Spanish Gov\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# make sure file you are opening is in the same directory\n",
    "\n",
    "# this is the older way to do this\n",
    "\n",
    "f = open('names.txt')\n",
    "\n",
    "data = f.read()\n",
    "\n",
    "print(data)\n",
    "\n",
    "# close when you are done so that you can use other sets of data later\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### with open()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hawkins, Derek\tderek@codingtemple.com\t(555) 555-5555\tTeacher, Coding Temple\t@derekhawkins\n",
      "Zhai, Mo\tmozhai@codingtemple.com\t(555) 555-5554\tTeacher, Coding Temple\n",
      "Johnson, Joe\tjoejohnson@codingtemple.com\t\tJohson, Joe\n",
      "Osterberg, Sven-Erik\tgovernor@norrbotten.co.se\t\tGovernor, Norrbotten\t@sverik\n",
      ", Tim\ttim@killerrabbit.com\t\tEnchanter, Killer Rabbit Cave\n",
      "Butz, Ryan\tryanb@codingtemple.com\t(555) 555-5543\tCEO, Coding Temple\t@ryanbutz\n",
      "Doctor, The\tdoctor+companion@tardis.co.uk\t\tTime Lord, Gallifrey\n",
      "Exampleson, Example\tme@example.com\t555-555-5552\tExample, Example Co.\t@example\n",
      "Pael, Ripal\tripalp@codingtemple.com\t(555) 555-5553\tTeacher, Coding Temple\t@ripalp\n",
      "Vader, Darth\tdarth-vader@empire.gov\t(555) 555-4444\tSith Lord, Galactic Empire\t@darthvader\n",
      "Fernandez de la Vega Sanz, Maria Teresa\tmtfvs@spain.gov\t\tFirst Deputy Prime Minister, Spanish Gov\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# more pythonic way to do it\n",
    "with open('names.txt') as f:\n",
    "    data = f.read()\n",
    "    print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.match()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 14), match='Hawkins, Derek'>\n"
     ]
    }
   ],
   "source": [
    "# search for raw datastring in file\n",
    "# with open('names.txt') as f:\n",
    "#     data = f.read()\n",
    "#     print(data)\n",
    "    \n",
    "print(re.match(r'Hawkins, Derek', data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### re.search()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(582, 605), match='ripalp@codingtemple.com'>\n"
     ]
    }
   ],
   "source": [
    "# with open('names.txt') as f:\n",
    "#     data = f.read()\n",
    "#     print(data)\n",
    "\n",
    "print(re.search(r\"ripalp@codingtemple.com\", data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Store the String to a Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What would you like to search for...Sith Lord\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/l6/k0bks1dx4wd409pkxgr263rm0000gn/T/ipykernel_67566/3581237373.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0manswer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"What would you like to search for...\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mfound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mre\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfindall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manswer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfound\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined"
     ]
    }
   ],
   "source": [
    "# with open('names.txt') as f:\n",
    "#     data = f.read()\n",
    "#     print(data)\n",
    "    \n",
    "answer = input(\"What would you like to search for... \")\n",
    "\n",
    "found = re.findall(answer, data)\n",
    "\n",
    "if found:\n",
    "    print(f\"I found your data: {found}\")\n",
    "else:\n",
    "    print(\"Nothing here folks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In-Class Exercise #3 <br>\n",
    "<p>Print each persons name and twitter handle, using groups, should look like:</p>\n",
    "<p>==============<br>\n",
    "   Full Name / Twitter<br>\n",
    "   ==============</p>\n",
    "Derek Hawkins / @derekhawkins\n",
    "\n",
    " Erik Sven-Osterberg / @sverik\n",
    "\n",
    " Ryan Butz / @ryanbutz\n",
    "\n",
    " Example Exampleson / @example\n",
    "\n",
    " Ripal Pael / @ripalp\n",
    "\n",
    " Darth Vader / @darthvader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=================\n",
      "Full Name/Twitter\n",
      "=================\n",
      "Derek Hawkins / @derekhawkins\n",
      "\n",
      "Coding Teacher / @sverik\n",
      "\n",
      "Mo Zhai / @ryanbutz\n",
      "\n",
      "Coding Teacher / @example\n",
      "\n",
      "Joe Johnson / @ripalp\n",
      "\n",
      "Joe Johson / @darthvader\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "# open file with information\n",
    "with open('names.txt') as f:\n",
    "    data = f.read()\n",
    "\n",
    "# pull cleaned full names into new list\n",
    "regex_names = r\"\\b[A-Z][a-zA-Z-]+[,]\\s\\b[A-Z][a-zA-Z-]+\" \n",
    "names = re.findall(regex_names, data)\n",
    "full_names = []\n",
    "for name in names:\n",
    "    x, y = name.split(',')\n",
    "    full_names.append(f\"{y.strip()} {x}\")\n",
    "\n",
    "# pull twitter handles into list\n",
    "regex_twitter = r\"\\B@[a-z]+\\b\"\n",
    "handles = re.findall(regex_twitter, data)\n",
    "\n",
    "# concatenate and print all information\n",
    "print('\\n=================\\nFull Name/Twitter\\n=================')\n",
    "for name, handle in zip(full_names, handles):\n",
    "    print(f\"{name} / {handle}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regex project\n",
    "\n",
    "Use python to read the file regex_test.txt and print the last name on each line using regular expressions and groups (return None for names with no first and last name, or names that aren't properly capitalized)\n",
    "##### Hint: use with open() and readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Expected Output\n",
    "Abraham Lincoln\n",
    "Andrew P Garfield\n",
    "Connor Milliken\n",
    "Jordan Alexander Williams\n",
    "None\n",
    "None\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abraham Lincoln\n",
      "Andrew P Garfield\n",
      "Connor Milliken\n",
      "Jordan Alexander Williams\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "# open file with information, return lines in list\n",
    "with open('../regex_test.txt') as f:\n",
    "    data = f.readlines()\n",
    "    \n",
    "# regex = '([first_name])([middle name(optional)]([last_name])'\n",
    "regex_name = r'\\b([A-Z][a-z]+)\\s([A-Z][a-z]*)*\\s*([A-Z][a-z]+)$'\n",
    "pattern = re.compile(regex_name)\n",
    "\n",
    "# if valid name, print name\n",
    "for i in data:\n",
    "    i = i[:-1]\n",
    "    match = pattern.match(i)\n",
    "    if match:\n",
    "        print(' '.join(part for part in (match.group(1), match.group(2), match.group(3)) if part))\n",
    "    else:\n",
    "        print('None')"
   ]
  },
  {
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}