NLP_Lab_5_Regular_Expressions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Experiment 5\n",
        "## Generate Regular Expressions for a given text."
      ],
      "metadata": {
        "id": "mH3wtwcqd1W7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Regular Expression\n",
        "A **regular expression** (regex or regexp) is a sequence of characters that define a search pattern.<br>\n",
        "It is a powerful tool used in Natural Language Processing (NLP) to search for specific patterns or structures in text data. <br>\n",
        "Regular expressions are highly expressive and can match many patterns, including numbers, dates, email addresses, and phone numbers. <br>\n",
        "They are useful for numerous practical day-to-day tasks that a data scientist encounters, such as data pre-processing, rule-based information mining systems, pattern matching, text feature engineering, web scraping, data extraction, etc.<br>\n",
        "\n",
        "Here are some key concepts related to regular expressions in NLP:\n",
        "\n",
        "- A regular expression is a sequence of characters that is used to find or replace patterns embedded in the text.\n",
        "- Regular expressions are used to recognize different strings of characters ¹.\n",
        "- Raw strings are used in regular expressions to treat backslashes as literal characters.\n",
        "- The `re` module in Python provides functions for working with regular expressions.\n",
        "- The `re.findall()` function is used to search for all occurrences that match a given pattern.\n",
        "- The `re.sub()` function is used to substitute the matched RE pattern with given text.\n",
        "- The `re.match()` function is used to match the RE pattern to string with some optional flags."
      ],
      "metadata": {
        "id": "Ui1nFXxbZZF1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Explanation Of The Code\n",
        "\n",
        "This code defines a function called `generate_regex` that takes a text input, escapes special characters, and generates a regular expression pattern based on the input text. Here's a breakdown of the code:\n",
        "\n",
        "### Importing the Required Library\n",
        "```python\n",
        "import re\n",
        "```\n",
        "This line imports the `re` module, which stands for regular expressions, and will be used for working with regular expressions in the code.\n",
        "\n",
        "### Function for Generating Regular Expression\n",
        "```python\n",
        "def generate_regex(text):\n",
        "    regex = re.escape(text)\n",
        "    regex = regex.replace(r'\\ ', r'\\s+')\n",
        "    return regex\n",
        "```\n",
        "This function, `generate_regex`, takes a text input and performs the following steps:\n",
        "\n",
        "1. `re.escape(text)`: This function escapes special characters in the input text, ensuring that they are treated as literal characters in the regular expression.\n",
        "\n",
        "2. `regex.replace(r'\\ ', r'\\s+')`: This line replaces escaped space characters (`\\ `) with `\\s+`, where `\\s` represents any whitespace character, and `+` means one or more occurrences. This modification allows for flexibility in matching multiple spaces in the input text.\n",
        "\n",
        "3. The final regular expression is returned.\n",
        "\n",
        "### Main Section\n",
        "```python\n",
        "if __name__ == '__main__':\n",
        "    text = 'This is a sample text'\n",
        "    regex = generate_regex(text)\n",
        "    print(f'Text is: {text}')\n",
        "    print(f'Generated Regular Expression is: {regex}')\n",
        "```\n",
        "The main section of the code initializes a sample text, calls the `generate_regex` function to create a regular expression based on the text, and then prints both the original text and the generated regular expression.\n",
        "\n",
        "### Explanation\n",
        "The purpose of this code is to create a regular expression pattern that can be used to match the input text, considering the input text may contain special characters and multiple spaces. The function aims to make the text suitable for pattern matching in a way that accounts for potential variations in spacing. This code then demonstrates the usage of the function with a sample text."
      ],
      "metadata": {
        "id": "wwWInMFa8UYs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importing the required library\n",
        "import re\n",
        "\n",
        "# Function for Generating Regular Expression\n",
        "def generate_regex(text):\n",
        "\n",
        "    regex = re.escape(text)\n",
        "\n",
        "    regex = regex.replace(r'\\ ', r'\\s+')\n",
        "\n",
        "    # Returning Regular Expression\n",
        "    return regex\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "    # Initializing Text\n",
        "    text = 'This is a sample text'\n",
        "\n",
        "    # Generating Regular Expression by calling the function\n",
        "    regex = generate_regex(text)\n",
        "\n",
        "    # Printing Text\n",
        "    print(f'Text is: {text}')\n",
        "\n",
        "    # Printing Regular Expression\n",
        "    print(f'Generated Regular Expression is: {regex}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hwDIxtRZZxtk",
        "outputId": "acc991a2-c8b9-4e62-cc7f-5ececb2402f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Text is: This is a sample text\n",
            "Generated Regular Expression is: This\\s+is\\s+a\\s+sample\\s+text\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "U4n8yKGtaGeM"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}