Assignment-7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regex: A regular expression is simply a sequence of characters that define a pattern.\n",
    "   \n",
    "   - why should you learn Regex:\n",
    "     - **They do a lot with less** –– You can write a few characters to do something that could have taken dozens of lines of code        to implement\n",
    "     - **Standing out from the crowd** –– Most programmers don't know regex. If you don't know it, you are about to detatch                yourself from that category\n",
    "     - **They are super fast** –– Regex patterns wrote with performance in mind takes a very short time to execute. Backtracking          might take some time, but even that has optimal variations that run super fast\n",
    "     - **They are portable** –– The majority of regex syntax works the same way in a variety of programming languages\n",
    "\n",
    "   - Common applications of regex are:\n",
    "     - Input validation (emails, usernames, passwords)\n",
    "     - Web scraping\n",
    "     - Data wrangling\n",
    "     - Simple parsing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AKASH', 'AKASH']\n",
      "['AKASH']\n"
     ]
    }
   ],
   "source": [
    "## The re.compile() function returns Regex objects.\n",
    "import re\n",
    "pattern = re.compile(\"AKASH\")\n",
    "result=pattern.findall('AKASH AB BORGALLI AKASH')\n",
    "print(result)\n",
    "result2=pattern.findall('AKASH is the best!!')\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raw strings are used so that backslashes do not have to be escaped."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 27), match='Python is powerful language'>\n"
     ]
    }
   ],
   "source": [
    "## The search() method returns Match objects.\n",
    "#Check if the string starts with \"Python\" and ends with \"language\":\n",
    "txt = \"Python is powerful language\"\n",
    "f = re.search(\"^Python.*language$\", txt)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Football\n"
     ]
    }
   ],
   "source": [
    "## The group() method returns strings of the matched text.\n",
    "#Search for an upper case \"F\" character in the beginning of a word, and print the word:\n",
    "import re\n",
    "txt = \"I play Football\"\n",
    "x = re.search(r\"\\bF\\w+\", txt)\n",
    "print(x.group())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Group 0 is the entire match, group 1 covers the first set of parentheses, and group 2 covers the second set of parentheses. Example given below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "91\n",
      "706-675-5472\n",
      "91-706-675-5472\n",
      "91-706-675-5472\n",
      "The country code is:  91\n",
      "Main number is:  706-675-5472\n"
     ]
    }
   ],
   "source": [
    "## Adding parentheses will create groups in the regex: (\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d). \n",
    "## Then you can use the group() match object method to grab the matching text from just one group.\n",
    "phoneNumRegex = re.compile(r'(\\d\\d)-(\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "mo = phoneNumRegex.search('My number is 91-706-675-5472.')\n",
    "print(mo.group(1))\n",
    "print(mo.group(2))\n",
    "print(mo.group(0))\n",
    "print(mo.group())\n",
    "## segregating areacode,main mumber\n",
    "CountryCode, mainNumber = mo.groups()\n",
    "print(\"The country code is: \",CountryCode)\n",
    "print(\"Main number is: \",mainNumber)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Periods and parentheses can be escaped with a backslash: \\., \\(, and \\)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ineuron@hotmail.com\n",
      "alex@yahoomail.com\n"
     ]
    }
   ],
   "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\n",
    "## findall() module is used to search for “all” occurrences that match a given pattern.\n",
    "abc = 'akash, ineuron@hotmail.com, alex@yahoomail.com'\n",
    "emails = re.findall(r'[\\w\\.-]+@[\\w\\.-]+', abc)\n",
    "for email in emails:\n",
    "    print(email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The | character signifies matching “either, or” between two groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The ? character can either mean “match zero or one of the preceding group” or be used to signify nongreedy matching."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['<html><head><title>Title</title>']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Greedy Behaviour\n",
    "## In below example, one may expect to get 4 matches, i.e. <html>, <head>, <title> and </title>.\n",
    "## Instead, we get the longest match, i.e. <html><head><title>Title</title>.\n",
    "## This particular behaviour (to find longest match) is called greedy behaviour.\n",
    "txt = \"\"\"<html><head><title>Title</title>\"\"\"\n",
    "pattern = re.compile(\"<.*>\")\n",
    "pattern.findall(txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['<html>', '<head>', '<title>', '</title>']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Non Greedy Behaviour\n",
    "## The non-greedy (or reluctant) behaviour can be requested by adding an extra question mark to the quantifier.\n",
    "## For example, ??, *? or +?.\n",
    "## A quantifier marked as reluctant will behave like the exact opposite of the greedy ones. They will try to have the smallest match possible.\n",
    "pattern = re.compile(\"<.*?>\")\n",
    "pattern.findall(txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The + matches one or more. The * matches zero or more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The {3} matches exactly three instances of the preceding group. The {3,5} matches between three and five instances."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The \\d, \\w, and \\s shorthand character classes match a single digit, word, or space character, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The \\D, \\W, and \\S shorthand character classes match a single character that is not a digit, word, or space character, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing re.I or re.IGNORECASE as the second argument to re.compile() will make the matching case insensitive"
   ]
  },
  {
   "cell_type": "markdown",
   "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",
   "metadata": {},
   "source": [
    "## The .* performs a greedy match, and the .*? performs a nongreedy match"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Either [0-9a-z] or [a-z0-9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X drummers, X pipers, five rings, X hen\n"
     ]
    }
   ],
   "source": [
    "numReg = re.compile(r'\\d+')\n",
    "soln = numReg.sub('X', '11 drummers, 10 pipers, five rings, 4 hen')\n",
    "print(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The re.VERBOSE argument allows you to add whitespace and comments to the string passed to re.compile()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## re.compile(r'^\\d{1,3}(,\\d{3})*$') will create this regex, but other regex strings can produce a similar regular expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "        if (window._pyforest_update_imports_cell) { window._pyforest_update_imports_cell('import re'); }\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['42', '1,234', '6,368,745']\n"
     ]
    }
   ],
   "source": [
    "## code for above ans\n",
    "str = '42 1,234 6,368,745 12,34,567 1234'\n",
    "regxp = re.compile(',[0-9]{1,2},|[0-9]{4,}')\n",
    "nums = [x for x in str.split() if not regxp.search(x)]\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## re.compile(r'[A-Z][a-z]*\\sNakamoto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## re.compile(r'(Alice|Bob|Carol)\\s(eats|pets|throws)\\s(apples|cats|baseballs)\\.', re.IGNORECASE)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}