regular_expression_or_Regex.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOrho4t9TPqZuC1lXRvUCjL",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hussain0048/Natural-language-processing/blob/main/regular_expression_or_Regex.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **1-Regular expression or Regex (Beginner Level)**"
      ],
      "metadata": {
        "id": "SQyTufDmwxWS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **1.1-Re- Module**"
      ],
      "metadata": {
        "id": "UI_PTfku9Aj9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i-06ohQqwf98"
      },
      "outputs": [],
      "source": [
        "# to use a regular expression, we need to import re\n",
        "import re"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Help**"
      ],
      "metadata": {
        "id": "cO8z13qSRf3-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(help(re))"
      ],
      "metadata": {
        "id": "0YEXihUWMzu_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Match**"
      ],
      "metadata": {
        "id": "634FNso0RcuT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "re.match('abc','abcdef')"
      ],
      "metadata": {
        "id": "c6_WmRbBxNkT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "word_regex= '\\w+'\n",
        "re.match(word_regex,' hi there!')"
      ],
      "metadata": {
        "id": "WdwKSsKoyEcR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# compile regex pattern\n",
        "# pattern to match any character\n",
        "str_pattern = r\"\\w\"\n",
        "pattern = re.compile(str_pattern)\n",
        "target_string = \"Jessa salary is 8000$\"\n",
        "# matching the starting string of the text\n",
        "result = pattern.match(target_string)\n",
        "# match character\n",
        "print(result.group())\n"
      ],
      "metadata": {
        "id": "WG4OY2h0UzK1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Search**"
      ],
      "metadata": {
        "id": "sYWzDLwLRm3B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Example 1"
      ],
      "metadata": {
        "id": "Rcb-cg_5Wpzi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "re.search('abc','abcde')"
      ],
      "metadata": {
        "id": "Lg_Pmsl1_ous",
        "outputId": "33e73b49-0628-4a27-ae0f-3127b0578762",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<re.Match object; span=(0, 3), match='abc'>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# search regex pattern anywhere inside the string\n",
        "# pattern to search any digit\n",
        "result= re.search(r\"\\d\", target_string)\n",
        "print(result.group())"
      ],
      "metadata": {
        "id": "acAHfGhkVza0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Example 2"
      ],
      "metadata": {
        "id": "fb8GifUTWmGU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sentence = \"My computer gives a very good performance in a very short time.\"\n",
        "string = \"very\""
      ],
      "metadata": {
        "id": "CjOSI5oPWa-w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str_match = re.search(string, sentence)\n",
        "str_match"
      ],
      "metadata": {
        "id": "zzAoFLShWj-3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can do some operations on this string also. To check all operations, write str_match. Then press the tab. It will show all operations.The is showing the span of the first string “very” here, 20 means it starts from the 20th index and finishes at the 24th index in the sentence."
      ],
      "metadata": {
        "id": "gvQVHlaeW4ut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str_match.span()"
      ],
      "metadata": {
        "id": "MuSX8u0YW6WN",
        "outputId": "3e4c6358-39ca-4440-ed83-cde6777167dc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(20, 24)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Split**"
      ],
      "metadata": {
        "id": "AO-J4V0yRjwA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "re.split('\\s+','split on spaces')"
      ],
      "metadata": {
        "id": "sYGj1FfR-2pM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Findall**"
      ],
      "metadata": {
        "id": "l0WLGayvRrtI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "PATTERN = r\"\\s+\"\n"
      ],
      "metadata": {
        "id": "TUVrbADmBPJM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PATTERN = r\"\\s+\"\n",
        "my_string = \" let's write RegEx!\"\n",
        "re.findall (PATTERN,my_string)"
      ],
      "metadata": {
        "id": "OJNqZkFwBAlF",
        "outputId": "72781764-d8b2-4d94-aff1-14df1714c8c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[' ', ' ', ' ']"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str_example = \"The house number is 29\"\n",
        "result = re.findall(r\"\\d\", str_example)\n",
        "\n",
        "# extracting digit\n",
        "print(result)\n",
        "\n",
        "#output:\n",
        "['2', '9']"
      ],
      "metadata": {
        "id": "x0xMF8_fSBAZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "find_all = re.findall(\"very\", sentence)\n",
        "find_all\n",
        "#output:\n",
        "['very', 'very']"
      ],
      "metadata": {
        "id": "RHB5ANI4Y7er",
        "outputId": "18ded590-c774-4679-bd46-6f90fb73267f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['very', 'very']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for word in re.finditer(\"very\", sentence):\n",
        "    print(word.span())"
      ],
      "metadata": {
        "id": "72tb_-sQZF6l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**re.compile**"
      ],
      "metadata": {
        "id": "xVzrsN8bUpCH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "target_string = \"Jessa salary is 8000$\"\n",
        "# compile regex pattern\n",
        "# pattern to match any character\n",
        "str_pattern = r\"\\w\"\n",
        "pattern = re.compile(str_pattern)"
      ],
      "metadata": {
        "id": "XJiS-2i3UX9g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Sub**"
      ],
      "metadata": {
        "id": "79TT6Q96MgS3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "target_string = \"Jessa salary is 8000$\"\n",
        "# regex for replacement\n",
        "# replace space with a hyphen\n",
        "result= re.sub(r\"\\s\", \"-\", target_string)\n",
        "#string after replacement\n",
        "print(result)\n",
        "# output:\n"
      ],
      "metadata": {
        "id": "vMMctRv1MVmk",
        "outputId": "0c0358af-8dbb-4841-844f-76b3639eab01",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jessa-salary-is-8000$\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **1.1-Exercise**"
      ],
      "metadata": {
        "id": "I4I3WXVOBnbc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Practicing regular expressions: re.split() and re.findall()**\n"
      ],
      "metadata": {
        "id": "_BnsT_-5BtOp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now you'll get a chance to write some regular expressions to match digits, strings and non-alphanumeric characters. Take a look at my_string first by printing it in the IPython Shell, to determine how you might best match the different steps.\n",
        "\n",
        "Note: It's important to prefix your regex patterns with r to ensure that your patterns are interpreted in the way you want them to. Else, you may encounter problems to do with escape sequences in strings. For example, \"\\n\" in Python is used to indicate a new line, but if you use the r prefix, it will be interpreted as the raw string \"\\n\" - that is, the character \"\\\" followed by the character \"n\" - and not as a new line.\n",
        "\n",
        "The regular expression module re has already been imported for you.\n",
        "\n",
        "Remember from the video that the syntax for the regex library is to always to pass the pattern first, and then the string second."
      ],
      "metadata": {
        "id": "fLfnB8HFBxZh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Instruction**\n",
        "\n",
        "Split my_string on each sentence ending. To do this:\n",
        "Write a pattern called sentence_endings to match sentence endings (.?!).\n",
        "Use re.split() to split my_string on the pattern and print the result.\n",
        "Find and print all capitalized words in my_string by writing a pattern called capitalized_words and using re.findall().\n",
        "Remember the [a-z] pattern shown in the video to match lowercase groups? Modify that pattern appropriately in order to match uppercase groups.\n",
        "Write a pattern called spaces to match one or more spaces (\"\\s+\") and then use re.split() to split my_string on this pattern, keeping all punctuation intact. Print the result.\n",
        "Find all digits in my_string by writing a pattern called digits (\"\\d+\") and using re.findall(). Print the result.\n",
        "Hints\n",
        "\n",
        "Remember, you can use \"\\w\" to match alphanumeric, \"\\d\" to match digits, \"\\s\" to match spaces and \"+\" to make anything greedy.\n",
        "For groupings, you can use square brackets [] to declare part of the pattern or the entire pattern."
      ],
      "metadata": {
        "id": "xpUydlDWB2gY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://drive.google.com/uc?export=view&id=1L74uBW0B0yejBKKq3e3dTPlvP78vqA2K)"
      ],
      "metadata": {
        "id": "ox4BOOoEChjZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**More regex with re.search()**\n"
      ],
      "metadata": {
        "id": "XhPIwyNGH487"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this exercise, you'll utilize re.search() and re.match() to find specific tokens. Both search and match expect regex patterns, similar to those you defined in an earlier exercise. You'll apply these regex library methods to the same Monty Python text from the nltk corpora.\n",
        "\n",
        "You have both scene_one and sentences available from the last exercise; now you can use them with re.search() and re.match() to extract and match more text.\n",
        "\n",
        "Instructions 1/3\n",
        "35 XP\n",
        "1\n",
        "2\n",
        "3\n",
        "Use re.search() to search for the first occurrence of the word \"coconuts\" in scene_one. Store the result in match.\n",
        "Print the start and end indexes of match using its .start() and .end() methods, respectively.\n",
        "\n",
        "Hint\n",
        "To create match, use re.search() with the arguments of interest - the word (\"coconuts\"), followed by the scene (scene_one).\n",
        "Once you've created match, you can use match.start() and match.end() inside a call to print() to print its start and end indexes."
      ],
      "metadata": {
        "id": "34msSchoIFiC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://drive.google.com/uc?export=view&id=1vGC3blZ6iNYGZ_l5Tugl8rnlC9N77i5a)"
      ],
      "metadata": {
        "id": "u2W0015MH93n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **3-Regular expression or Regex (advance Level)**"
      ],
      "metadata": {
        "id": "Yvz6gz9IY69X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**3.1-Exercise**"
      ],
      "metadata": {
        "id": "VyaRwbGuZF-J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **3.1.1-Non-ascii tokenization**"
      ],
      "metadata": {
        "id": "u4B6cfD5ZRoX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Non-ascii tokenization\n",
        "In this exercise, you'll practice advanced tokenization by tokenizing some non-ascii based text. You'll be using German with emoji!\n",
        "\n",
        "Here, you have access to a string called german_text, which has been printed for you in the Shell. Notice the emoji and the German characters!\n",
        "\n",
        "The following modules have been pre-imported from nltk.tokenize: regexp_tokenize and word_tokenize.\n",
        "\n",
        "Unicode ranges for emoji are:\n",
        "\n",
        "('\\U0001F300'-'\\U0001F5FF'), ('\\U0001F600-\\U0001F64F'), ('\\U0001F680-\\U0001F6FF'), and ('\\u2600'-\\u26FF-\\u2700-\\u27BF')."
      ],
      "metadata": {
        "id": "8NBKJs2uZXRZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Instructions**"
      ],
      "metadata": {
        "id": "pQOHAxB3ZckQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tokenize all the words in german_text using word_tokenize(), and print the result.\n",
        "\n",
        "Tokenize only the capital words in german_text.\n",
        "\n",
        "First, write a pattern called capital_words to match only capital words. Make sure to check for the German Ü! To use this character in the exercise, copy and paste it from these instructions.\n",
        "Then, tokenize it using regexp_tokenize().\n",
        "Tokenize only the emoji in german_text. The pattern using the unicode ranges for emoji given in the assignment text has been written for you. Your job is to use regexp_tokenize() to tokenize the emoji."
      ],
      "metadata": {
        "id": "ntCaF9LyZleq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Hints**"
      ],
      "metadata": {
        "id": "BYdg7G24Zz2G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To tokenize all the words in german_text, pass it in as an argument to word_tokenize().\n",
        "The pattern to match only capital words is r\"[A-ZÜ]\\w+\".\n",
        "To write the pattern to match emoji, separate the unicode ranges for emoji shown in the assignment text using |. After writing the patterns, be sure to tokenize using regexp_tokenize() and then print the results."
      ],
      "metadata": {
        "id": "k9ufxC6UZxx-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://drive.google.com/uc?export=view&id=1CTMcOqYLy-oWHDHAgT_vk86TkUd0-aYG)"
      ],
      "metadata": {
        "id": "ZzuGyB4pZ2Y5"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tj7VmHRyBwsI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wvjaDwY9Br_v"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}