Regular Expressions - Pattern Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular Expressions\n",
    "## Pattern Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "what if we do not have a constant search pattern and we want to return specific set of characters (defined by a rule) from a string? This can easily be solved by defining an expression with the help of pattern operators (meta  and literal characters)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Most Commonly Used Operators\n",
    "Regular expressions can specify patterns, not just fixed characters. Here are the most commonly used operators that helps to generate an expression to represent required characters in a string or file. It is commonly used in web scrapping and  text mining to extract required information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operators &nbsp; | &nbsp; &nbsp; Description\n",
    "-------------------------------------\n",
    "<pre>\n",
    ".\t       | Matches with any single character except newline ‘\\n’.\n",
    "?\t       | match 0 or 1 occurrence of the pattern to its left\n",
    "+\t       | 1 or more occurrences of the pattern to its left\n",
    "*\t       | 0 or more occurrences of the pattern to its left\n",
    "\\w\t      | Matches with a alphanumeric character whereas \\W (upper case W) matches non alphanumeric character.\n",
    "\\d\t      | Matches with digits [0-9] and /D (upper case D) matches with non-digits.\n",
    "\\s\t      | Matches with a single white space character (space, newline, return, tab, form) and \\S (upper case S) \n",
    "            | matches any non-white space character.\n",
    "\\b\t      | boundary between word and non-word and /B is opposite of /b\n",
    "[..]\t    | Matches any single character in a square bracket and [^..] matches any single character not in square \n",
    "            | bracket\n",
    "\\\t       | It is used for special meaning characters like \\. to match a period or \\+ for plus sign.\n",
    "^ and $\t    | ^ and $ match the start or end of the string respectively\n",
    "{n,m}\t   | Matches at least n and at most m occurrences of preceding expression if we write it as {,m} then it will \n",
    "            | return at least any minimum occurrence to max m preceding expression.\n",
    "a| b\t    | Matches either a or b\n",
    "( )\t     | Groups regular expressions and returns matched text\n",
    "\\t, \\n, \\r  | Matches tab, newline, return\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1: Return the first word of a given string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-1  Extract each character (using “.”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "result=re.findall(r'.','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A',\n",
       " 'V',\n",
       " ' ',\n",
       " 'i',\n",
       " 's',\n",
       " ' ',\n",
       " 'l',\n",
       " 'a',\n",
       " 'r',\n",
       " 'g',\n",
       " 'e',\n",
       " 's',\n",
       " 't',\n",
       " ' ',\n",
       " 'A',\n",
       " 'n',\n",
       " 'a',\n",
       " 'l',\n",
       " 'y',\n",
       " 't',\n",
       " 'i',\n",
       " 'c',\n",
       " 's',\n",
       " ' ',\n",
       " 'c',\n",
       " 'o',\n",
       " 'm',\n",
       " 'm',\n",
       " 'u',\n",
       " 'n',\n",
       " 'i',\n",
       " 't',\n",
       " 'y',\n",
       " ' ',\n",
       " 'o',\n",
       " 'f',\n",
       " ' ',\n",
       " 'I',\n",
       " 'n',\n",
       " 'd',\n",
       " 'i',\n",
       " 'a']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, space is also extracted. Let us avoid it using “\\w” instead of “.”. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-2  Extract each character (using “\\w”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A',\n",
       " 'V',\n",
       " 'i',\n",
       " 's',\n",
       " 'l',\n",
       " 'a',\n",
       " 'r',\n",
       " 'g',\n",
       " 'e',\n",
       " 's',\n",
       " 't',\n",
       " 'A',\n",
       " 'n',\n",
       " 'a',\n",
       " 'l',\n",
       " 'y',\n",
       " 't',\n",
       " 'i',\n",
       " 'c',\n",
       " 's',\n",
       " 'c',\n",
       " 'o',\n",
       " 'm',\n",
       " 'm',\n",
       " 'u',\n",
       " 'n',\n",
       " 'i',\n",
       " 't',\n",
       " 'y',\n",
       " 'o',\n",
       " 'f',\n",
       " 'I',\n",
       " 'n',\n",
       " 'd',\n",
       " 'i',\n",
       " 'a']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-3  Extract each word (using “ * ” or “+”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w*','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV',\n",
       " '',\n",
       " 'is',\n",
       " '',\n",
       " 'largest',\n",
       " '',\n",
       " 'Analytics',\n",
       " '',\n",
       " 'community',\n",
       " '',\n",
       " 'of',\n",
       " '',\n",
       " 'India',\n",
       " '']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, it is returning space as a word because “ * ” returns zero or more matches of pattern to its left. Now to remove spaces we will go with “+”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-4 Extract each word (using “^”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'^\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we use “$” instead of “^”, it will return the word from the end of the string. Let’s look at it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w+$','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['India']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2: Return the first two character of each word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-1  Extract consecutive two characters of each word, excluding spaces (using “\\w”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w\\w','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV',\n",
       " 'is',\n",
       " 'la',\n",
       " 'rg',\n",
       " 'es',\n",
       " 'An',\n",
       " 'al',\n",
       " 'yt',\n",
       " 'ic',\n",
       " 'co',\n",
       " 'mm',\n",
       " 'un',\n",
       " 'it',\n",
       " 'of',\n",
       " 'In',\n",
       " 'di']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-2  Extract consecutive two characters those available at start of word boundary (using “\\b”)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\b\\w.','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV', 'is', 'la', 'An', 'co', 'of', 'In']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3: Return the domain type of given email-ids"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-1  Extract all characters after “@”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'@\\w+','abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['@gmail', '@test', '@analyticsvidhya', '@rest']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you can see that “.com”, “.in” part is not extracted. To add it, we will go with below code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'@\\w+.\\w+','abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['@gmail.com', '@test.in', '@analyticsvidhya.com', '@rest.biz']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution – 2 Extract only domain name using “( )”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'@\\w+.(\\w+)','abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['com', 'in', 'com', 'biz']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4: Return date from given string\n",
    "Here we will use “\\d” to extract digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\d{2}-\\d{2}-\\d{4}','Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['12-05-2007', '11-11-2011', '12-01-2009']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to extract only year again parenthesis “( )” will help you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\d{2}-\\d{2}-(\\d{4})','Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2007', '2011', '2009']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 5: Return all words of a string those which start with vowel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-1  Return each words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution-2  Return words starts with alphabets (using [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'[aeiouAEIOU]\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV', 'is', 'argest', 'Analytics', 'ommunity', 'of', 'India']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above you can see that it has returned “argest” and “ommunity” from the mid of words. To drop these two, we need to use “\\b” for word boundary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solution- 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\b[aeiouAEIOU]\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AV', 'is', 'Analytics', 'of', 'India']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In similar ways, we can extract words those which start with consonants using “^” within square bracket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\b[^aeiouAEIOU]\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[' is', ' largest', ' Analytics', ' community', ' of', ' India']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above you can see that it has returned words starting with space. To drop it from output, include space in square bracket[]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=re.findall(r'\\b[^aeiouAEIOU ]\\w+','AV is largest Analytics community of India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['largest', 'community']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 6: Validate a phone number (phone number must be of 10 digits and starts with 8 or 9)\n",
    "We have a list of phone numbers in list “li” and here we will validate phone numbers using regular expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n",
      "no\n",
      "no\n"
     ]
    }
   ],
   "source": [
    "li=['9999999999','999999-999','99999x9999']\n",
    "for val in li:\n",
    "    if re.match(r'[8-9]{1}[0-9]{9}',val) and len(val) == 10:\n",
    "        print ('yes')\n",
    "    else:\n",
    "        print ('no')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 7: Split a string with multiple delimiters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = 'asdf fjdk;afed,fjek,asdf,foo' # String has multiple delimiters (\";\",\",\",\" \").\n",
    "result= re.split(r'[;,\\s]', line)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use method re.sub() to replace these multiple delimiters with one as space “ ”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'asdf fjdk afed fjek asdf foo'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = 'asdf fjdk;afed,fjek,asdf,foo'\n",
    "result= re.sub(r'[;,\\s]',' ', line)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 8: Retrieve Information from HTML file\n",
    "I want to extract information from a HTML file (see below sample data). Here we need to extract information available between <td> and </td> except the first numerical index. I have assumed here that below html code is stored in a string <b>str</b>.\n",
    "\n",
    "Sample HTML file (str)\n",
    "<pre>\n",
    "\"<tr align=\"center\"><td>1</td> <td>Noah</td> <td>Emma</td></tr>\"\n",
    "\"<tr align=\"center\"><td>2</td> <td>Liam</td> <td>Olivia</td></tr>\"\n",
    "\"<tr align=\"center\"><td>3</td> <td>Mason</td> <td>Sophia</td></tr>\"\n",
    "\"<tr align=\"center\"><td>4</td> <td>Jacob</td> <td>Isabella</td></tr>\"\n",
    "\"<tr align=\"center\"><td>5</td> <td>William</td> <td>Ava</td></tr>\"\n",
    "\"<tr align=\"center\"><td>6</td> <td>Ethan</td> <td>Mia</td></tr>\"\n",
    "\"<tr align=\"center\"><td>7</td> <td HTML>Michael</td> <td>Emily</td></tr>\"==$0\n",
    "</pre>\n",
    "<strong>Solution:</strong>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = '<tr align=\"center\"><td>1</td> <td>Noah</td> <td>Emma</td></tr><tr align=\"center\"><td>2</td> <td>Liam</td> <td>Olivia</td></tr><tr align=\"center\"><td>3</td> <td>Mason</td> <td>Sophia</td></tr><tr align=\"center\"><td>4</td> <td>Jacob</td> <td>Isabella</td></tr><tr align=\"center\"><td>5</td> <td>William</td> <td>Ava</td></tr><tr align=\"center\"><td>6</td> <td>Ethan</td> <td>Mia</td></tr><tr align=\"center\"><td>7</td> <td HTML>Michael</td> <td>Emily</td></tr>'\n",
    "result=re.findall(r'<td>\\w+</td>\\s<td>(\\w+)</td>\\s<td>(\\w+)</td>',str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Noah', 'Emma'),\n",
       " ('Liam', 'Olivia'),\n",
       " ('Mason', 'Sophia'),\n",
       " ('Jacob', 'Isabella'),\n",
       " ('William', 'Ava'),\n",
       " ('Ethan', 'Mia')]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read html file using library urllib2 (see below code)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'urllib2'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-46-331f0672622b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0murllib2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mresponse\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0murllib2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'https://www.w3schools.com/html/'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mhtml\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mresponse\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'urllib2'"
     ]
    }
   ],
   "source": [
    "import urllib2\n",
    "response = urllib2.urlopen('https://www.w3schools.com/html/')\n",
    "html = response.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'training_queries@analyticsvidhya.com'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = \"Contact us on training_queries@analyticsvidhya.com\" \n",
    "pattern = \"([\\w.]+)@([\\w.]+)\"\n",
    "match = re.search(pattern, string).group(0)\n",
    "match"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}