Regular_Expressions_Basics sir.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zf0s_g8kcGwX"
   },
   "source": [
    "# Regular Expressions (RegEx)\n",
    "\n",
    "**r** expression is used to create a raw string. Python raw string treats backslash (\\\\) as a literal character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "ysDOlmTieBoD",
    "outputId": "994a3681-a956-4c4f-b3c4-e625cca8001c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string: C:\\desktop\\peterchapagain\n"
     ]
    }
   ],
   "source": [
    "# normal string vs raw string\n",
    "path = \"C:\\\\desktop\\\\peterchapagain\"  #string\n",
    "print(\"string:\",path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw string: C:\\\\desktop\\\\peterchapagain\n"
     ]
    }
   ],
   "source": [
    "path= r\"C:\\\\desktop\\\\peterchapagain\"  #raw string\n",
    "print(\"raw string:\",path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi how are you? \n",
      " answer:\n"
     ]
    }
   ],
   "source": [
    "sen=\"Hi how are you? \\n answer:\"\n",
    "print(sen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi how are you? \\n answer:\n"
     ]
    }
   ],
   "source": [
    "sen=r\"Hi how are you? \\n answer:\"\n",
    "print(sen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPORT 're'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### compare codes used with filter() with other examples listed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "name=['vivek','aliza','ram','dipesh','pragati','anish','govinda']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results with filter() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aliza', 'anish']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter((lambda x: re.match(r'a', x)),name)) #list all name begining with 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dipesh', 'anish']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter((lambda x: re.match(r'.*sh$', x)),name))  #list name ending with 'sh'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aliza', 'ram', 'pragati', 'anish', 'govinda']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter((lambda x: re.match(r'.*a.*', x)),name))  #list name that includes 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['vivek', 'aliza', 'ram', 'anish']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter((lambda x: re.match(r'(a|v|r)', x)),name))  #list all names that begin with 'a or v or r' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trying here with map()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<re.Match object; span=(0, 5), match='vivek'>,\n",
       " <re.Match object; span=(0, 5), match='aliza'>,\n",
       " <re.Match object; span=(0, 3), match='ram'>,\n",
       " None,\n",
       " None,\n",
       " <re.Match object; span=(0, 5), match='anish'>,\n",
       " None]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: re.match(r'(a|v|r).*', x),name))  #list all names that begin with 'a or v or r' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<re.Match object; span=(0, 5), match='vivek'>, <re.Match object; span=(0, 5), match='aliza'>, <re.Match object; span=(0, 3), match='ram'>, None, None, <re.Match object; span=(0, 5), match='anish'>, None]\n",
      "\n",
      "\n",
      "Total matches : 7\n"
     ]
    }
   ],
   "source": [
    "l=list(map(lambda x: re.match(r'(a|v|r).*', x),name))\n",
    "\n",
    "print(l)\n",
    "print(\"\\n\")\n",
    "print(\"Total matches :\",len(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploring 're'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BzgUXp2t5t__"
   },
   "source": [
    "### Normally, it is always recommended to use raw strings while dealing with regular expressions. \n",
    "\n",
    "Python has a built-in module to work with regular expressions called **re**. Some of the commonly used methods from the **re** module are listed below:\n",
    "\n",
    "1.re.match(): This function checks if \n",
    "\n",
    "2.re.search()\n",
    "\n",
    "3.re.findall()\n",
    "\n",
    "<br>\n",
    "\n",
    "Let us look at each method with the help of example.\n",
    "\n",
    "**1. re.match()**\n",
    "\n",
    "The re.match function returns a match object on success and none on failure. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "LiXEkNiFsuyl",
    "outputId": "fabb06b0-d45b-4730-ccf8-77ab0ac5a9c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 6), match='Python'>\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "#match a word at the beginning of a string\n",
    "\n",
    "result = re.match('Python',r'Python and data science, huge group of programmers choose Python') \n",
    "print(result)\n",
    "\n",
    "result_2 = re.match('Programming',r'Python and data science, huge group of Programming choose Python') \n",
    "print(result_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8vocMyh-ecWx"
   },
   "source": [
    "Since output of the re.match is an object, we will use *group()* function of match object to get the matched expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "UH1qzis2ebvp",
    "outputId": "8f61d1ce-cd38-41aa-cc0a-58e28cde7fb7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    }
   ],
   "source": [
    "print(result.group())  #returns the total matches\n",
    "\n",
    "#print(result_2.group())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kamRye8242ZW"
   },
   "source": [
    "<br>\n",
    "\n",
    "**2. re.search()**\n",
    "\n",
    "Matches the first occurence of a pattern in the entire string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "tPWpkEMT15yo",
    "outputId": "46d61b97-fd53-4afe-b26b-e758878c1831"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data\n"
     ]
    }
   ],
   "source": [
    "# search for the pattern \"founded\" in a given string\n",
    "result = re.search('data',r'Python and data science, huge group of programmers choose Python')\n",
    "print(result.group())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C3rEa5tA-p1v"
   },
   "source": [
    "<br>\n",
    "\n",
    "**3. re.findall()**\n",
    "\n",
    "It will return all the occurrences of the pattern from the string. I would recommend you to use *re.findall()* always, it can work like both *re.search()* and *re.match()*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "FnX7nhmm15wv",
    "outputId": "3b711ff4-0abc-4018-ec57-476f574f6f8c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data', 'science', 'data']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall('(data|python|science)',r'Python and data science, huge group of programmers choose Python')  \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the last Parameter!\n",
    "re.IGNORECASE, re.MULTILINE ...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'data', 'science', 'Python']\n"
     ]
    }
   ],
   "source": [
    "#trying Case related search for 'Python'\n",
    "result1 = re.findall('(data|python|science)',r'Python and data science, huge group of programmers choose Python',re.IGNORECASE)  \n",
    "print(result1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xQmyJ3li_FA4"
   },
   "source": [
    "### Special sequences\n",
    "\n",
    "1. **\\A**\treturns a match if the specified pattern is at the beginning of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "h-sfPEgn-QY5",
    "outputId": "5062ca03-b54f-47da-ada2-99c7dd8ea410"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Towards']\n",
      "['Towards']\n"
     ]
    }
   ],
   "source": [
    "str = r'Towardsdatascience.com is the largest data science community'\n",
    "\n",
    "x = re.findall(\"\\Aowards\", str)\n",
    "print(x)\n",
    "\n",
    "x1 = re.findall(\"^Towards\", str)\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is useful in cases where you have multiple strings of text, and you have to extract the first word only, given that first word is 'Towards'.\n",
    "\n",
    "If you would try to find some other word, then it will return an empty list as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "str = r'Towardsdatascience.com is the largest data science community'\n",
    "\n",
    "x = re.findall(\"\\APython\", str)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9cuV3PLx_0QN"
   },
   "source": [
    "2. **\\b** returns a match where the specified pattern is at the beginning or at the end of a word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "WHo26_h_-QcB",
    "outputId": "e8d25f02-07e9-4366-f8f5-f6eba0f77b9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['est']\n"
     ]
    }
   ],
   "source": [
    "#Check if there is any word that ends with \"est\"\n",
    "x = re.findall(r\"est\\b\", str)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jf8OMVMH-a3F"
   },
   "source": [
    "It returns the last three characters of the word \"largest\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "t8rjV3vrBKRz"
   },
   "source": [
    "3. **\\B**\treturns a match where the specified pattern is present, but NOT at the beginning (or at the end) of a word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ZQv4iybYsus6",
    "outputId": "95bb6666-9f22-4772-b359-f5b03d8e1715"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['enc', 'enc']\n"
     ]
    }
   ],
   "source": [
    "str = r'Towardsdatascience.com is the largest data science community'\n",
    "\n",
    "x = re.findall(r\"\\Benc\", str)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I5dAw37yBkKb"
   },
   "source": [
    "4. **\\d** returns a match where the string contains digits (numbers from 0-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "bJfck2AgsRYO",
    "outputId": "bb2281b3-ffd5-4cb6-c79f-a6f2f74116d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '1', '9']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits since Jan'19.\"\n",
    "\n",
    "#Check if the string contains any digits (numbers from 0-9):\n",
    "x = re.findall(\"\\d\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "RPfU5fMNiu6o",
    "outputId": "1df13433-9d4c-4fba-c0e9-2007698ead6e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '19']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits in Jan'19.\"\n",
    "\n",
    "# Check if the string contains any digits (numbers from 0-9):\n",
    "# adding '+' after '\\d' will continue to extract digits till encounters a space\n",
    "x = re.findall(\"\\d+\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VmrhSJKkjAR2"
   },
   "source": [
    "We can infer that **\\d+** repeats one or more occurences of **\\d** till the non maching character is found where as **\\d** does character wise comparison."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CLmRsnBDB5xm"
   },
   "source": [
    "5. **\\D** returns a match where the string does not contain any digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "YvbdEkeIBaWJ",
    "outputId": "74cbbede-d223-4402-cc27-edcf11c579db"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', 'm', 'i', 'l', 'l', 'i', 'o', 'n', ' ', 'm', 'o', 'n', 't', 'h', 'l', 'y', ' ', 'v', 'i', 's', 'i', 't', 's', ' ', 'i', 'n', ' ', 'J', 'a', 'n', \"'\", '.']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits in Jan'19.\"\n",
    "\n",
    "#Check if the word character does not contain any digits (numbers from 0-9):\n",
    "x = re.findall(\"\\D\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "nQ-LMSjijs3A",
    "outputId": "0f30af5e-5173-4d99-c982-ec38a34799f7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\" million monthly visits'\"]\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits'19\"\n",
    "\n",
    "#Check if the word does not contain any digits (numbers from 0-9):\n",
    "\n",
    "x = re.findall(\"\\D+\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m4IXrubzCSKD"
   },
   "source": [
    "6. **\\w** helps in extraction of alphanumeric characters only (characters from a to Z, digits from 0-9, and the underscore _ character)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "27BWx3NwBaZQ",
    "outputId": "208f7b35-dbcb-44e7-89a0-43ae9ac5cfe8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', 'm', 'i', 'l', 'l', 'i', 'o', 'n', 'm', 'o', 'n', 't', 'h', 'l', 'y', 'v', 'i', 's', 'i', 't', 's']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits!\"\n",
    "\n",
    "#returns a match at every word character (characters from a to Z, digits from 0-9, and the underscore _ character)\n",
    "\n",
    "x = re.findall(\"\\w\",str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "h7SH3j7Aj5Iv",
    "outputId": "a5fbdd01-35b1-49e0-82a1-4179fbd721fe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', 'million', 'monthly', 'visits']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits!\"\n",
    "\n",
    "#returns a match at every word (characters from a to Z, digits from 0-9, and the underscore _ character)\n",
    "\n",
    "x = re.findall(\"\\w+\",str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nk_D9U6yh6GN"
   },
   "source": [
    "7. **\\W** returns match at every non alphanumeric character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "BdeL-GATCRlT",
    "outputId": "6adb4e1f-80f9-4e64-fb53-fc3b80d1bb08"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', ' ', ' ', '!']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"2 million monthly visits9!\"\n",
    "\n",
    "#returns a match at every NON word character (characters NOT between a and Z. Like \"!\", \"?\" white-space etc.):\n",
    "\n",
    "x = re.findall(\"\\W\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UIaXDjPYDT1S"
   },
   "source": [
    "## Metacharacters\n",
    "\n",
    "Metacharacters are characters with a special meaning\n",
    "\n",
    "1. **(.)** matches any character (except newline character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "hFZuFqBdDS3l",
    "outputId": "2bcbb8db-927f-4a06-8f57-14e4c1be5765"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['roh', 'roh']\n",
      "['rohan', 'rohit']\n"
     ]
    }
   ],
   "source": [
    "str = \"rohan and rohit recently published a research paper!\" \n",
    "\n",
    "#Search for a string that starts with \"ro\", followed by three (any) characters\n",
    "\n",
    "x = re.findall(\"ro.\", str)\n",
    "x2 = re.findall(\"ro...\", str)\n",
    "\n",
    "print(x)\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zI7dJWYpDl3G"
   },
   "source": [
    "2. **(^)** starts with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "_3uPdcQPDlR0",
    "outputId": "cc06c976-a0a3-469a-ba55-0503bda9504d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, the string starts with 'Data'\n"
     ]
    }
   ],
   "source": [
    "str = \"Data Science\"\n",
    "\n",
    "#Check if the string starts with 'Data':\n",
    "x = re.findall(\"^Data\", str)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, the string starts with 'Data'\")\n",
    "else:\n",
    "  print(\"No match\")\n",
    "  \n",
    "#print(x)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "QTbvAIFfHAVY",
    "outputId": "f707ecb3-6fc2-4e65-ea43-dfb6474aa67b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No match\n"
     ]
    }
   ],
   "source": [
    "# try with a different string\n",
    "str2 = \"Big Data\"\n",
    "\n",
    "#Check if the string starts with 'Data':\n",
    "x2 = re.findall(\"^Data\", str2)\n",
    "\n",
    "if (x2):\n",
    "  print(\"Yes, the string starts with 'data'\")\n",
    "else:\n",
    "  print(\"No match\")\n",
    "  \n",
    "#print(x2)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8uPoaY_ID0LW"
   },
   "source": [
    "3. **($)** ends with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "IK_XYDpmC9f_",
    "outputId": "ced47b00-2868-4d5e-f79e-dcf06adcce89"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, the string ends with 'Science'\n"
     ]
    }
   ],
   "source": [
    "str = \"Data Science\"\n",
    "\n",
    "#Check if the string ends with 'Science':\n",
    "\n",
    "x = re.findall(\"Science$\", str)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, the string ends with 'Science'\")\n",
    "\n",
    "else:\n",
    "  print(\"No match\")\n",
    "  \n",
    "#print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Fz089xrhD-HP"
   },
   "source": [
    "4. (*) matches for zero or more occurences of the pattern to the left of it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "5vXhYm30CRi4",
    "outputId": "2fd5763b-9d58-4642-ac9c-ee62bf26130d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['easy', 'easssy', 'eay']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"easy easssy eay ey\"\n",
    "\n",
    "#Check if the string contains \"ea\" followed by 0 or more \"s\" characters and ending with y\n",
    "x = re.findall(\"eas*y\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O7zkTLHqY3wa"
   },
   "source": [
    "5. **(+)** matches one or more occurences of the pattern to the left of it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "20iFZpA2CRgo",
    "outputId": "115859ad-fe83-4638-e937-26f21a0fcd19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['easy', 'easssy']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "#Check if the string contains \"ea\" followed by 1 or more \"s\" characters and ends with y \n",
    "x = re.findall(\"eas+y\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F7V5GysyXEip"
   },
   "source": [
    "6. **(?)** matches zero or one occurrence of the pattern left to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "RAOJuCOLXCli",
    "outputId": "f9184025-9edf-48ea-a213-61d9edb1f04b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['easy', 'eay']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"easy easssy eay ey\"\n",
    "x = re.findall(\"eas?y\",str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jwH40pYTu-tX"
   },
   "source": [
    "7. **(|)** either or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "dyMYGwnoCRfJ",
    "outputId": "f42cb57a-a345-45f9-f62f-1cfc1d30177c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data', 'science', 'data', 'science']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"Towardsdatascience.com is the largest data science community\"\n",
    "\n",
    "#Check if the string contains either \"data\" or \"India\":\n",
    "\n",
    "x = re.findall(\"data|science\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "X9oEfQT9KWfs",
    "outputId": "cb47cc84-56f7-4a1e-8411-09d2d18205b8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data', 'data']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "# try with a different string\n",
    "str = \"Towardsdatascience.com is the largest data science community\"\n",
    "\n",
    "#Check if the string contains either \"data\" or \"India\":\n",
    "\n",
    "x = re.findall(\"data|nepal|USA\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Bvc01ip_E_la"
   },
   "source": [
    "## Sets\n",
    "\n",
    "1. A set is a bunch of characters inside a pair of square brackets [ ] with a special meaning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "qvUXj2t6EgqK",
    "outputId": "cf487ee4-c408-4c6b-9f36-e881fad60f5b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['d', 'd', 'h', 'd', 'y']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"Towardsdatascience.com is the largest data science community\"\n",
    "\n",
    "#Check for the characters y, d, or h, in the above string\n",
    "x = re.findall(\"[ydh]\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "SsizfCMeK7w0",
    "outputId": "57c7fde7-41ee-4426-a981-a11206e31c88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'd', 'd', 'a', 'a', 'c', 'e', 'c', 'e', 'c', 'e', 'a', 'g', 'e', 'd', 'a', 'a', 'c', 'e', 'c', 'e', 'c']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"Towardsdatascience.com is the largest data science community\"\n",
    "\n",
    "#Check for the characters between a and g, in the above string\n",
    "x = re.findall(\"[a-g]\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "Let's solve a problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['230']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"Mars' average distance from the Sun is roughly 230 million km and its orbital period is 687 (Earth) days.\"\n",
    "\n",
    "# extract the numbers starting with 0 to 4 from in the above string\n",
    "x = re.findall(r\"\\b[0-4]\\d+\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F9fLACdByqG4"
   },
   "source": [
    "2. **[^]** Check whether string has other characters mentioned after ^"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "E-RchTxCFB9Z",
    "outputId": "9331baa0-3c0a-41fb-a2a6-92dc5128c080"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['T', 'o', 'w', 'a', 'r', 's', 'a', 't', 'a', 's', 'c', 'i', 'e', 'n', 'c', 'e', '.', 'c', 'o', 'm', ' ', 'i', 's', ' ', 't', 'e', ' ', 'l', 'a', 'r', 'g', 'e', 's', 't', ' ', 'a', 't', 'a', ' ', 's', 'c', 'i', 'e', 'n', 'c', 'e', ' ', 'c', 'o', 'm', 'm', 'u', 'n', 'i', 't']\n",
      "Yes, there is at least one match!\n"
     ]
    }
   ],
   "source": [
    "str = \"Towardsdatascience.com is the largest data science community\"\n",
    "\n",
    "#Check if every word character has characters than y, d, or h\n",
    "\n",
    "x = re.findall(\"[^ydh]\", str)\n",
    "\n",
    "print(x)\n",
    "\n",
    "if (x):\n",
    "  print(\"Yes, there is at least one match!\")\n",
    "else:\n",
    "  print(\"No match\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fNBEj1LcynpI"
   },
   "source": [
    "3. **[a-zA-Z0-9]** : Check whether string has alphanumeric characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "me1WBtD3FCAm",
    "outputId": "e16b2890-2872-4c99-8814-886d78c31b10"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['.com']\n"
     ]
    }
   ],
   "source": [
    "str = \"Largest Data Science community: anishchapagain.com!!\"\n",
    "\n",
    "# extract words that start with a special character\n",
    "x = re.findall(\"[^a-zA-Z0-9 ]\\w+\", str)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "58EH37MJ3b2t"
   },
   "source": [
    "---\n",
    "## Solve Complex Queries\n",
    "\n",
    "Let us try solving some complex queries using regex.\n",
    "\n",
    "### Extracting Email IDs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lWfrRxAD177J",
    "outputId": "198f03cc-f1a5-4df2-c144-48c2dd9bcdb5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['user1.1997@gmail.com', 'user2_user@yahoo.com', 'mail@yahoo.com']\n"
     ]
    }
   ],
   "source": [
    "str = 'Send a mail to user1.1997@gmail.com, user2_user@yahoo.com and mail@yahoo.com about the meeting @2PM'\n",
    "  \n",
    "# \\w matches any alpha numeric character \n",
    "# + for repeats a character one or more times \n",
    "#x = re.findall('\\w+@\\w+\\.com', str)     \n",
    "x = re.findall('[a-zA-Z0-9._-]+@\\w+\\.com', str)     \n",
    "  \n",
    "# Printing of List \n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7ay1r2VtudqM"
   },
   "source": [
    "### Extracting Dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "9OQgTr944Cb1",
    "outputId": "3d77fb7c-ac08-4d71-adbf-52cfe1c76f1e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2012-07-27', '2012/08/12']\n"
     ]
    }
   ],
   "source": [
    "text = \"London Olympic 2012 was held from 2012-07-27 to 2012/08/12.\"\n",
    "\n",
    "# '\\d{4}' repeats '\\d' 4 times\n",
    "match = re.findall('\\d{4}.\\d{2}.\\d{2}', text)\n",
    "print(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "HF81uLVQ7FgR",
    "outputId": "ab7d0053-936c-447a-d193-09ba084d360b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['27 Jul 2012', '12-Aug-2012']\n"
     ]
    }
   ],
   "source": [
    "text=\"London Olympic 2012 was held from 27 Jul 2012 to 12-Aug-2012.\"\n",
    "\n",
    "match = re.findall('\\d{2}.\\w{3}.\\d{4}', text)\n",
    "\n",
    "print(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "8Z8akvWP7FZg",
    "outputId": "741ffecd-b2a0-431b-9a2d-b6a76e8a1f82"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['27 July 2012', '12 August 2012']\n"
     ]
    }
   ],
   "source": [
    "# extract dates with varying lengths\n",
    "text=\"London Olympic 2012 was held from 27 July 2012 to 12 August 2012.\"\n",
    "\n",
    "#'\\w{3,10}' repeats '\\w' 3 to 10 times\n",
    "match = re.findall('\\d{2}.\\w{3,10}.\\d{4}', text)\n",
    "\n",
    "print(match)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iEL6f3Sh43ES"
   },
   "source": [
    "## Extracting Title from Names - Titanic Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aGBisMqj17-u"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# load dataset\n",
    "data=pd.read_csv(\"titanic.csv\")\n",
    "\n",
    "print(type(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 233
    },
    "colab_type": "code",
    "id": "6Ub0VxewsbhW",
    "outputId": "4d86ba33-62ce-4044-f6d7-e56bfa1b8fc0"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PassengerId</th>\n",
       "      <th>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Name</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Ticket</th>\n",
       "      <th>Fare</th>\n",
       "      <th>Cabin</th>\n",
       "      <th>Embarked</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Braund, Mr. Owen Harris</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>A/5 21171</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Cumings, Mrs. John Bradley (Florence Briggs Th...</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>PC 17599</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>C85</td>\n",
       "      <td>C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>Heikkinen, Miss. Laina</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>STON/O2. 3101282</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Futrelle, Mrs. Jacques Heath (Lily May Peel)</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>113803</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>C123</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Allen, Mr. William Henry</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>373450</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PassengerId  Survived  Pclass  \\\n",
       "0            1         0       3   \n",
       "1            2         1       1   \n",
       "2            3         1       3   \n",
       "3            4         1       1   \n",
       "4            5         0       3   \n",
       "\n",
       "                                                Name     Sex   Age  SibSp  \\\n",
       "0                            Braund, Mr. Owen Harris    male  22.0      1   \n",
       "1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n",
       "2                             Heikkinen, Miss. Laina  female  26.0      0   \n",
       "3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n",
       "4                           Allen, Mr. William Henry    male  35.0      0   \n",
       "\n",
       "   Parch            Ticket     Fare Cabin Embarked  \n",
       "0      0         A/5 21171   7.2500   NaN        S  \n",
       "1      0          PC 17599  71.2833   C85        C  \n",
       "2      0  STON/O2. 3101282   7.9250   NaN        S  \n",
       "3      0            113803  53.1000  C123        S  \n",
       "4      0            373450   8.0500   NaN        S  "
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 217
    },
    "colab_type": "code",
    "id": "dOGNZ1ZZsblF",
    "outputId": "6e4ddf6a-0a90-4c6a-a151-819c3aec5c95"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0                              Braund, Mr. Owen Harris\n",
       "1    Cumings, Mrs. John Bradley (Florence Briggs Th...\n",
       "2                               Heikkinen, Miss. Laina\n",
       "3         Futrelle, Mrs. Jacques Heath (Lily May Peel)\n",
       "4                             Allen, Mr. William Henry\n",
       "5                                     Moran, Mr. James\n",
       "6                              McCarthy, Mr. Timothy J\n",
       "7                       Palsson, Master. Gosta Leonard\n",
       "8    Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)\n",
       "9                  Nasser, Mrs. Nicholas (Adele Achem)\n",
       "Name: Name, dtype: object"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print a few passenger names\n",
    "data['Name'].head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PassengerId</th>\n",
       "      <th>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>891.000000</td>\n",
       "      <td>891.000000</td>\n",
       "      <td>891.000000</td>\n",
       "      <td>714.000000</td>\n",
       "      <td>891.000000</td>\n",
       "      <td>891.000000</td>\n",
       "      <td>891.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>446.000000</td>\n",
       "      <td>0.383838</td>\n",
       "      <td>2.308642</td>\n",
       "      <td>29.699118</td>\n",
       "      <td>0.523008</td>\n",
       "      <td>0.381594</td>\n",
       "      <td>32.204208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>257.353842</td>\n",
       "      <td>0.486592</td>\n",
       "      <td>0.836071</td>\n",
       "      <td>14.526497</td>\n",
       "      <td>1.102743</td>\n",
       "      <td>0.806057</td>\n",
       "      <td>49.693429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.420000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>223.500000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>20.125000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>7.910400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>446.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>28.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>14.454200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>668.500000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>38.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>31.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>891.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>80.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>512.329200</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       PassengerId    Survived      Pclass         Age       SibSp  \\\n",
       "count   891.000000  891.000000  891.000000  714.000000  891.000000   \n",
       "mean    446.000000    0.383838    2.308642   29.699118    0.523008   \n",
       "std     257.353842    0.486592    0.836071   14.526497    1.102743   \n",
       "min       1.000000    0.000000    1.000000    0.420000    0.000000   \n",
       "25%     223.500000    0.000000    2.000000   20.125000    0.000000   \n",
       "50%     446.000000    0.000000    3.000000   28.000000    0.000000   \n",
       "75%     668.500000    1.000000    3.000000   38.000000    1.000000   \n",
       "max     891.000000    1.000000    3.000000   80.000000    8.000000   \n",
       "\n",
       "            Parch        Fare  \n",
       "count  891.000000  891.000000  \n",
       "mean     0.381594   32.204208  \n",
       "std      0.806057   49.693429  \n",
       "min      0.000000    0.000000  \n",
       "25%      0.000000    7.910400  \n",
       "50%      0.000000   14.454200  \n",
       "75%      0.000000   31.000000  \n",
       "max      6.000000  512.329200  "
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe() #presents with general stat related information!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JnKqBitc4-lY"
   },
   "source": [
    "### Method 1: One way is to split on the pandas dataframe and extract the title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Allen, Mr', ' William Henry']\n"
     ]
    }
   ],
   "source": [
    "name = \"Allen, Mr. William Henry\"\n",
    "name2 = name.split(\".\")\n",
    "print(name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Allen', ' Mr']"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2[0].split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 345
    },
    "colab_type": "code",
    "id": "1mwxei9VEgwY",
    "outputId": "7255baab-b3dc-4e62-cef2-542e7067afa3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "title=data['Name'].apply(lambda x: x.split(\".\")[0].split(\",\")[1])\n",
    "\n",
    "print(type(title))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### value_counts() ! remember .......(from collections import Counter) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total values : 17\n"
     ]
    }
   ],
   "source": [
    "title.value_counts() #value_counts() important!!!!!\n",
    "print(\"Total values :\", len(title.value_counts()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " Mr              517\n",
       " Miss            182\n",
       " Mrs             125\n",
       " Master           40\n",
       " Dr                7\n",
       " Rev               6\n",
       " Mlle              2\n",
       " Col               2\n",
       " Major             2\n",
       " Sir               1\n",
       " Don               1\n",
       " Ms                1\n",
       " Lady              1\n",
       " Capt              1\n",
       " Mme               1\n",
       " the Countess      1\n",
       " Jonkheer          1\n",
       "Name: Name, dtype: int64"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "title.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e2KgKMgE5seE"
   },
   "source": [
    "This method might not work all the time. Therefore, another more robust way is to define pattern and search for it using regex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 2: Use RegEx to extract titles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WZdKNY7NyaiF"
   },
   "outputs": [],
   "source": [
    "def split_it(name):\n",
    "    return re.findall(\"\\w+\\.\",name)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 345
    },
    "colab_type": "code",
    "id": "RqL2F-Fw2byQ",
    "outputId": "d7add7f4-91cd-492f-c60e-faf753fc2454",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0         Mr.\n",
      "1        Mrs.\n",
      "2       Miss.\n",
      "3        Mrs.\n",
      "4         Mr.\n",
      "5         Mr.\n",
      "6         Mr.\n",
      "7     Master.\n",
      "8        Mrs.\n",
      "9        Mrs.\n",
      "10      Miss.\n",
      "11      Miss.\n",
      "12        Mr.\n",
      "13        Mr.\n",
      "14      Miss.\n",
      "Name: Name, dtype: object\n",
      "----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "title=data['Name'].apply(lambda x: split_it(x))\n",
    "\n",
    "print(title[0:15])  #partial results\n",
    "print(\"----\"*25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0nePjWD9IWbl"
   },
   "source": [
    "In the above result, we observe that the title is followed by '.' since we are searching for a pattern that includes '.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Total: \n",
      " Mr.          517\n",
      "Miss.        182\n",
      "Mrs.         125\n",
      "Master.       40\n",
      "Dr.            7\n",
      "Rev.           6\n",
      "Mlle.          2\n",
      "Col.           2\n",
      "Major.         2\n",
      "Lady.          1\n",
      "Countess.      1\n",
      "Sir.           1\n",
      "Jonkheer.      1\n",
      "Don.           1\n",
      "Mme.           1\n",
      "Capt.          1\n",
      "Ms.            1\n",
      "Name: Name, dtype: int64\n",
      "----------------------------------------------------------------------------------------------------\n",
      "\n",
      " Total:  891\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n Total: \\n\", title.value_counts()) #individual results with their counts\n",
    "\n",
    "print(\"----\"*25)\n",
    "print(\"\\n Total: \", title.value_counts().sum()) #sum of all results!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### set() for individual values from 'title'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mr.', 'Dr.', 'Ms.', 'Col.', 'Countess.', 'Don.', 'Miss.', 'Mrs.', 'Rev.', 'Mlle.', 'Sir.', 'Capt.', 'Jonkheer.', 'Major.', 'Lady.', 'Master.', 'Mme.']\n",
      "Total in a set:  17\n"
     ]
    }
   ],
   "source": [
    "print(list(set(title)))  #distinguish titles from title!\n",
    "print(\"Total in a set: \",len(list(set(title))))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Regular Expressions anish.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}