Regular+Expressions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Regular expressions called regex are implemented as re Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#regex pattern \n",
    "import re\n",
    "regex=re.compile('\\s+')\n",
    "\n",
    "#'\\s' denotes a white space character.\n",
    "#By adding a '+', we wish to match at least one or more white spaces\n",
    "#The above compiles a regualar expression pattern that can match at least one or more white space characters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['101',\n",
       " 'COM',\n",
       " 'Computer',\n",
       " 'Science',\n",
       " '205',\n",
       " 'MAT',\n",
       " 'Mathematics',\n",
       " '189',\n",
       " 'ENG',\n",
       " 'English']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#split a string separated by a regex\n",
    "\n",
    "import re\n",
    "text= \"\"\"101 COM   Computer Science\n",
    "205 MAT   Mathematics\n",
    "189 ENG    English\"\"\"\n",
    "\n",
    "#[course number] [course code] [course name] \n",
    "#The spacing between the words is not equal\n",
    "\n",
    "#spilt the text around 1 or more space characters\n",
    "re.split('\\s+',text)\n",
    "\n",
    "#or\n",
    "regex.split(text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 COM   Computer Science\n",
      "205 MAT   Mathematics\n",
      "189 ENG    English\n"
     ]
    }
   ],
   "source": [
    "#Finding pattern matches using findall\n",
    "\n",
    "#find all numbers within the text\n",
    "print(text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['101', '205', '189']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex_num=re.compile('\\d+')\n",
    "regex_num.findall(text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#'\\d' is a regualar expression for digits. Adding a '+' at the end mandates the presence of more than one digit\n",
    "#'*' on the other hand, requires 0 or more digits in order to be found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#re.search() versus re.match()\n",
    "#regex.serach() searches for the pattern in a given text\n",
    "#it returns a particular matched object that contains the starting and end positions of the first occurrence of the pattern\n",
    "\n",
    "#regex.match() also returns a match object. The difference is that it requires the pattern to be present at the beginning of the text\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Position:  39\n",
      "Ending Position  42\n",
      "189\n"
     ]
    }
   ],
   "source": [
    "text2=\"\"\"COM  computers\n",
    "MAT    Mathematics      189\"\"\"\n",
    "\n",
    "regex_num=re.compile('\\d+')  #here the pattern to be searched is nothing but a number\n",
    "s=regex_num.search(text2)\n",
    "\n",
    "print('Starting Position: ',s.start())\n",
    "print('Ending Position ', s.end())\n",
    "print(text2[s.start() : s.end()])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "189\n"
     ]
    }
   ],
   "source": [
    "print(s.group())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "m=regex_num.match(text2)\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 COM \t Computers\n",
      "205 MAT \t Mathematics\n",
      "189 ENG \t English\n"
     ]
    }
   ],
   "source": [
    "#substitute one text with another: regex.sub()\n",
    "\n",
    "text=\"\"\"101 COM \\t Computers\n",
    "205 MAT \\t Mathematics\n",
    "189 ENG \\t English\"\"\"\n",
    "\n",
    "print(text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 COM Computers 205 MAT Mathematics 189 ENG English\n"
     ]
    }
   ],
   "source": [
    "#even out the extra spaces and put all the words in a single line\n",
    "regex=re.compile('\\s+')\n",
    "print(regex.sub(' ', text))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 COM Computers 205 MAT Mathematics 189 ENG English\n"
     ]
    }
   ],
   "source": [
    "#or\n",
    "\n",
    "print(re.sub('\\s+', ' ', text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101 COM Computers\n",
      "205 MAT Mathematics\n",
      "189 ENG English\n"
     ]
    }
   ],
   "source": [
    "#suppose we want to get rid of all the extra spaces but want the course entries in the same line itself \n",
    "#this can be done witha negative lookahead (?!\\n). It checks for an upcoming newline character and excludes it from the pattern\n",
    "\n",
    "#get rid of all the extra spaces except newline\n",
    "regex=re.compile('((?!\\n)\\s+)')\n",
    "print(regex.sub(' ', text))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#regex groups- lets you extract the desired match objects as individual items "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['101', '205', '189']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Wish to extract the course number, code and name as separate items without regex groups-\n",
    "\n",
    "text=\"\"\"101 COM Computers\n",
    "205 MAT Mathematics\n",
    "189 ENG English\"\"\"\n",
    "\n",
    "#1.extract all course numbers \n",
    "re.findall('[0-9]+', text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['COM', 'MAT', 'ENG']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2.extract all course codes\n",
    "re.findall('[A-Z]{3}', text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Computers', 'Mathematics', 'English']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#3.extract all course names\n",
    "re.findall('[A-Za-z]{4,}', text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('101', 'COM', 'Computers'),\n",
       " ('205', 'MAT', 'Mathematics'),\n",
       " ('189', 'ENG', 'English')]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#extracting with regex groups-\n",
    "\n",
    "#define the course pattern\n",
    "course_pattern='([0-9]+)\\s*([A-Z]{3})\\s*([A-Za-z]{4,})'\n",
    "re.findall(course_pattern, text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<body> Regex Greedy Matching Example </body>']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#greedy matching in regex- default behaviour of regular expresions is to be greedy. It tries to extract as much as possible until it conforms to a pattern even when a smaller part wouldve been syntactically sufficient \n",
    "\n",
    "text=\"<body> Regex Greedy Matching Example </body> \"\n",
    "re.findall('<.*>', text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<body>', '</body>']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#it extracted the whole string instead of matching till the first occurrence of '>'(end of the fist body tag). this is the by default greedy behaviour of regex\n",
    "#lazy matching takes as little as possible. This can be done by adding '?' at the end of the pattern\n",
    "\n",
    "re.findall('<.*?>', text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<body>'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search('<.*?>', text).group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'h', 'a', 't', 'i', 's', 'y', 'o', 'u', 'r', 'n', 'a', 'm', 'e', '?']\n"
     ]
    }
   ],
   "source": [
    "#regex examples\n",
    "\n",
    "text=\"what is your name?\"\n",
    "print(re.findall('[^\\s]', text))  #one character other than a whitespace\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'h', 'a', 't', 'i', 's', 'y', 'o', 'u', 'r', 'n', 'a', 'm', 'e', '?']\n"
     ]
    }
   ],
   "source": [
    "print(re.findall('[^^^\\s]', text))   # three characters other than a whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cooool']\n"
     ]
    }
   ],
   "source": [
    "#match one or more occurrences. use r before the '' for matching occurrences\n",
    "print(re.findall(r'Co+l','So Cooool'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#match word boundaries- \\b commonly used to detect and match the beginning or end of a word\n",
    "#example the regex \\btoy will match 'toy' in 'toy cat' and not in 'tolstoy' (use toy\\b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['toy', 'toy']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(r'\\btoy','play toy broke toys')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['toy']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(r'\\Btoy\\b', 'tolstoy toys')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}