2.4 Regular Expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.4 Regular Expressions\n",
    "\n",
    "Regular expressions, or \"regex\" for short, is a special syntax for searching for strings that meets a specified pattern. It's a great tool to filter and sort through text when you want to match patterns rather than a hard coded string or strings. \n",
    "\n",
    "There are loads of options for the syntax so it's best to just jump in and get started with some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raw Strings\n",
    "\n",
    "Python recognises certain characters to have a special meaning, for example, \\n in python is used to indicate a new line. However, sometimes these codes that python recognises to have certain meanings appear in our strings and we want to tell python that a \\n in our text is a literal \\n, rather than meaning a new line. \n",
    "\n",
    "We can use the 'r' character before strings to indicate to python that our text is what is known as a \"raw string\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\desktop\n",
      "otes\n"
     ]
    }
   ],
   "source": [
    "# print text without using raw string indicator\n",
    "my_folder = \"C:\\desktop\\notes\"\n",
    "print(my_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how the python interprets the \\n to mean a new line! Now let's try it as a raw string..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\desktop\\notes\n"
     ]
    }
   ],
   "source": [
    "# include raw string indicator\n",
    "my_folder = r\"C:\\desktop\\notes\"\n",
    "print(my_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The folder path is now printed as we wanted. This is important to keep in mind when working with regular expressions as we'll want to make sure we are using raw strings when working with special characters. It's also just a good habit to get into when working with strings and regular expressions so you don't get caught out!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## re.search\n",
    "\n",
    "re.search is a function which allows us to check if a certain pattern is in a string. It uses the logic re.search(\"pattern to find\", \"string to find it in\"). It will return the pattern if it is found in the string, or else it will return None if the pattern is not found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(22, 29), match='pattern'>\n"
     ]
    }
   ],
   "source": [
    "result_search = re.search(\"pattern\", r\"string containing the pattern\")\n",
    "print(result_search)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pattern\n"
     ]
    }
   ],
   "source": [
    "print(result_search.group()) # returns just the matching pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "result_search = re.search(\"pattern\",r\"the phrase to find isn't in this string\")\n",
    "print(result_search) # returns None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## re.sub\n",
    "\n",
    "re.sub allows us to find certain text and replace it. It uses the logic re.sub(\"pattern to find\", \"replacement text\", \"string\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = r\"sara was able to help me find the items i needed quickly\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sarah was able to help me find the items i needed quickly\n"
     ]
    }
   ],
   "source": [
    "new_string = re.sub(r\"sara\", r\"sarah\", string) # replace the incorrect spelling of sarah\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regex Syntax\n",
    "\n",
    "The real power of regex is being able to leverage the syntax to create more complex searches/replacements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "customer_reviews = ['sam was a great help to me in the store', \n",
    "                    'the cashier was very rude to me, I think her name was eleanor', \n",
    "                    'amazing work from sadeen!', \n",
    "                    'sarah was able to help me find the items i needed quickly', \n",
    "                    'lucy is such a great addition to the team', \n",
    "                    'great service from sara she found me what i wanted'\n",
    "                   ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Find only sarah's reviews but account for the spelling of sara**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sarahs_reviews = []\n",
    "pattern_to_find = r\"sarah?\" \n",
    "# the ? after r means it is an optional character to match, so our search will look for sarah and sara"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "for string in customer_reviews:\n",
    "    if (re.search(pattern_to_find, string)):\n",
    "        sarahs_reviews.append(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sarah was able to help me find the items i needed quickly', 'great service from sara she found me what i wanted']\n"
     ]
    }
   ],
   "source": [
    "print(sarahs_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Find reviews that start with the letter a**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_reviews = []\n",
    "pattern_to_find = r\"^a\" # the ^ operator to indicates the start of a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "for string in customer_reviews:\n",
    "    if (re.search(pattern_to_find, string)):\n",
    "        a_reviews.append(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['amazing work from sadeen!']\n"
     ]
    }
   ],
   "source": [
    "print(a_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Find reviews that end with the letter y**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_reviews = []\n",
    "pattern_to_find = r\"y$\" # the $ operator to indicate the end of a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "for string in customer_reviews:\n",
    "    if (re.search(pattern_to_find, string)):\n",
    "        y_reviews.append(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sarah was able to help me find the items i needed quickly']\n"
     ]
    }
   ],
   "source": [
    "print(y_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Find reviews that contain the words needed or wanted**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "needwant_reviews = []\n",
    "pattern_to_find = r\"(need|want)ed\" # the pipe operator | can be used to mean OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for string in customer_reviews:\n",
    "    if (re.search(pattern_to_find, string)):\n",
    "        needwant_reviews.append(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sarah was able to help me find the items i needed quickly', 'great service from sara she found me what i wanted']\n"
     ]
    }
   ],
   "source": [
    "print(needwant_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remove anything from the review that isn't a word or a space (i.e. remove punctuation)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "no_punct_reviews = []\n",
    "pattern_to_find = r\"[^\\w\\s]\" \n",
    "# [^ ] means \"not\", \\w means word and \\s means whitespace: so find anything that is not a word or a space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "for string in customer_reviews:\n",
    "    no_punct_string = re.sub(pattern_to_find, \"\", string)\n",
    "    no_punct_reviews.append(no_punct_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sam was a great help to me in the store', 'the cashier was very rude to me I think her name was eleanor', 'amazing work from sadeen', 'sarah was able to help me find the items i needed quickly', 'lucy is such a great addition to the team', 'great service from sara she found me what i wanted']\n"
     ]
    }
   ],
   "source": [
    "print(no_punct_reviews)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "nlp_course_env",
   "language": "python",
   "name": "nlp_course_env"
  },
  "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.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}