TASK6_RegEX_Regular_Expression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMM0wMpc2oE73AitDqygkWB",
      "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/aneeshmurali-n/Python-Tasks/blob/main/TASK6_RegEX_Regular_Expression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Write a Python program to check that a string contains only a certain set of characters (in this case a-z, A-Z and 0-9)."
      ],
      "metadata": {
        "id": "nXQIJ4wCHM6u"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DTbAXp9Hy2pl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad336baa-6ba2-475b-8a2c-46d71aaf62f4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a string to test if it contains only the characters a-z, A-Z, and 0-9    :    23rt^\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "# Define a function to check if the input string contains only a-z, A-Z, and 0-9\n",
        "def check_a_z_A_Z_0_9(ip_string):\n",
        "    pattern = re.compile(r'^[a-zA-Z0-9]+$') # Compile a regular expression pattern that matches only a-z, A-Z, and 0-9\n",
        "    if re.match(pattern, ip_string):        # Use the compiled pattern to match the input string\n",
        "        return True                         # Return True if the string matches the pattern\n",
        "    else:\n",
        "        return False                        # Return False if the string does not match the pattern\n",
        "\n",
        "# Prompt the user to enter a string and check if it contains only the allowed characters\n",
        "print(check_a_z_A_Z_0_9(input(\"Enter a string to test if it contains only the characters a-z, A-Z, and 0-9    :    \")) )"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#2. Write a Python program that matches a string that has an a followed by zero or more b's."
      ],
      "metadata": {
        "id": "n5ENK-15Rb8g"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "def match_a_followed_by_zero_or_more_bs(ip_string):\n",
        "    # Compile the regex pattern to match 'a' followed by zero or more 'b's\n",
        "    pattern = re.compile(r'^ab*')\n",
        "\n",
        "    # Use the pattern to match the input string\n",
        "    if pattern.fullmatch(ip_string):\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "# Test cases\n",
        "test_strings = [\"a\", \"apple\", \"ab\", \"ball\", \"abb\", \"bat\",\"abbb\", \"b\", \"aa\", \"aab\", \"ac\", \"dc\"]\n",
        "\n",
        "for string in test_strings:\n",
        "    print(f'Test string \"{string}\" , match = {match_a_followed_by_zero_or_more_bs(string)}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L6dQzWW2Rd5H",
        "outputId": "11d2fc76-59ba-42fc-9ab0-0baeebbf4121"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test string \"a\" , match = True\n",
            "Test string \"apple\" , match = False\n",
            "Test string \"ab\" , match = True\n",
            "Test string \"ball\" , match = False\n",
            "Test string \"abb\" , match = True\n",
            "Test string \"bat\" , match = False\n",
            "Test string \"abbb\" , match = True\n",
            "Test string \"b\" , match = False\n",
            "Test string \"aa\" , match = False\n",
            "Test string \"aab\" , match = False\n",
            "Test string \"ac\" , match = False\n",
            "Test string \"dc\" , match = False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3. Replace only the first occurrence of 5 with five for the given string 'They ate 5 apples and 5 oranges'"
      ],
      "metadata": {
        "id": "QFSXrRSnYYdN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "ip = 'They ate 5 apples and 5 oranges' # Initial string\n",
        "\n",
        "ip = re.sub(\"5\", \"five\", ip, 1)        # def sub(pattern, repl, string, count=0, flags=0)\n",
        "# - pattern: The regular expression pattern to search for (\"5\" in this case)\n",
        "# - repl: The replacement string (\"five\")\n",
        "# - string: The input string in which to search and replace (ip)\n",
        "# - count: The maximum number of pattern occurrences to be replaced (1 in this case, meaning only the first occurrence)\n",
        "\n",
        "print(ip)                              # Print the modified string"
      ],
      "metadata": {
        "id": "vaaiCv_AYjT8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5eb26d85-b6b6-4219-8f7b-7efb63b49cb7"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "They ate five apples and 5 oranges\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#4. Write a Python program that matches a string that has an a followed by three 'b'."
      ],
      "metadata": {
        "id": "n2jZ9dz-WnAl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "def match_a_followed_by_three_bs(ip_string):\n",
        "    # Compile the regex pattern to match 'a' followed by three 'b's\n",
        "    pattern = re.compile(r'ab{3}')\n",
        "\n",
        "    # Use the pattern to match the input string\n",
        "    if re.search(pattern,ip_string):\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "# Test cases\n",
        "test_strings = [\"a\", \"apple\", \"abcdefabbbddd\", \"ball\", \"abb\", \"bat\",\"abbb\", \"b\", \"aa\", \"aab\", \"ac\", \"dc\"]\n",
        "\n",
        "for string in test_strings:\n",
        "    print(f'Test string \"{string}\" , match = {match_a_followed_by_three_bs(string)}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0LF6Qy3gW0pl",
        "outputId": "11801a6b-6f8a-4458-c7aa-a4be86d98021"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test string \"a\" , match = False\n",
            "Test string \"apple\" , match = False\n",
            "Test string \"abcdefabbbddd\" , match = True\n",
            "Test string \"ball\" , match = False\n",
            "Test string \"abb\" , match = False\n",
            "Test string \"bat\" , match = False\n",
            "Test string \"abbb\" , match = True\n",
            "Test string \"b\" , match = False\n",
            "Test string \"aa\" , match = False\n",
            "Test string \"aab\" , match = False\n",
            "Test string \"ac\" , match = False\n",
            "Test string \"dc\" , match = False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#5. Write a Python program that matches a string that has an 'a' followed by anything ending in 'b'."
      ],
      "metadata": {
        "id": "9ksTRmyKY0jd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "def match_a_followed_by_anything_ending_in_b(input_string):\n",
        "    pattern = r\"a.*b$\" # regex pattern to match 'a' followed by anything ending in 'b'\n",
        "    if re.search(pattern, input_string):\n",
        "       return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "# Test strings\n",
        "test_strings = [\"apple tab\", \"ab\", \"absorb\", \"XYZ axis\", \"123ab\", \"adverb\", \"aero@bomb\", \"b\"]\n",
        "\n",
        "# Loop through the test strings and check if they match the pattern\n",
        "for string in test_strings :\n",
        "    print(f'Test string \"{string}\" , match = {match_a_followed_by_anything_ending_in_b(string)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pDl6RUKlY_Yd",
        "outputId": "ef1d9583-8520-4c72-8fd7-d943852071ea"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test string \"apple tab\" , match = True\n",
            "Test string \"ab\" , match = True\n",
            "Test string \"absorb\" , match = True\n",
            "Test string \"XYZ axis\" , match = False\n",
            "Test string \"123ab\" , match = True\n",
            "Test string \"adverb\" , match = True\n",
            "Test string \"aero@bomb\" , match = True\n",
            "Test string \"b\" , match = False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#6. Write a Python program to search for numbers (0-9) of length between 1 and 3 in a given string."
      ],
      "metadata": {
        "id": "GWwUbSzce469"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "def filter_numbers(ipstring,numlength):\n",
        "    pattern = r\"\\b\\d{1,\"+ str(numlength)+ r\"}\\b\" # pattern to match numbers of length between 1 and numlength\n",
        "    return re.findall(pattern, txt) # retun all match list\n",
        "    #\\b asserts a word boundary\n",
        "    #\\d{min,max} matches between 1 and numlength of digits.\n",
        "    #\\b asserts another word boundary to ensure the match is a complete number.\n",
        "\n",
        "txt = \"Exercises number 1, 12, 13, and 345 are important\" # Input string\n",
        "# Print the matches\n",
        "print(f\"Numbers of length between 1 and 3 in the given string: {filter_numbers(txt,3)}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aDSPZPSVf92W",
        "outputId": "0c5d1575-3fb4-4d74-9b01-03abe5a5dd2a"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Numbers of length between 1 and 3 in the given string: ['1', '12', '13', '345']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#7. Write a Python program to search for literal strings within a string.\n",
        "Sample text : 'The quick brown fox jumps over the lazy dog.'\n",
        "Searched words : 'fox', 'dog', 'horse'"
      ],
      "metadata": {
        "id": "OCZmLdxum8FN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "search_words = [ 'fox', 'dog', 'horse' ]\n",
        "sample_text = 'The quick brown fox jumps over the lazy dog.'\n",
        "for search_word in search_words: # Loop through each word in the search_words list\n",
        "    if re.search(search_word,sample_text): #def search(pattern, string, flags=0)\n",
        "        print(f\"search for '{search_word}' in string '{sample_text}' : Match found\")\n",
        "    else:\n",
        "        print(f\"search for '{search_word}' in string '{sample_text}' : Match not found\")\n",
        ""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xOer2urOn6ZW",
        "outputId": "13778b99-29bc-484a-d49b-1fbba9f99cda"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "search for 'fox' in string 'The quick brown fox jumps over the lazy dog.' : Match found\n",
            "search for 'dog' in string 'The quick brown fox jumps over the lazy dog.' : Match found\n",
            "search for 'horse' in string 'The quick brown fox jumps over the lazy dog.' : Match not found\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#8. Write a Python program to search for a literal string in a string and also find the location within the original string where the pattern occurs.\n",
        "\n",
        "Sample text : 'The quick brown fox jumps over the lazy dog.' \\\n",
        "Searched words : 'fox'"
      ],
      "metadata": {
        "id": "2cgZLc6Yd0sE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "search_word = 'fox'\n",
        "sample_text = 'The quick brown fox jumps over the lazy dog.'\n",
        "matched = re.search(search_word,sample_text) #def search(pattern, string, flags=0)\n",
        "\n",
        "if matched:\n",
        "    print(f\"search for '{search_word}' in string '{sample_text}' : Match found\")\n",
        "    print(f\"Location : from {matched.start()} to {matched.end()-1}\")\n",
        "    # Print the location of the match\n",
        "    # matched.start() returns the starting index of the match\n",
        "    # matched.end() returns the ending index of the match (exclusive), so we subtract 1 to get the zero-based end index\n",
        "    for loc in range(matched.start(),matched.end()):\n",
        "        print(f\"index {loc} = {sample_text[loc]}\")\n",
        "else:\n",
        "    print(f\"search for '{search_word}' in string '{sample_text}' : Match not found\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gToCuo-4vBy6",
        "outputId": "3ce74db8-6c8e-4825-d69e-57ccc65f2c6e"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "search for 'fox' in string 'The quick brown fox jumps over the lazy dog.' : Match found\n",
            "Location : from 16 to 18\n",
            "index 16 = f\n",
            "index 17 = o\n",
            "index 18 = x\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#9.  Write a Python program to extract year, month and date from an URL"
      ],
      "metadata": {
        "id": "d3ZNAMom7aTq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "url1= \"https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/\"\n",
        "pattern = r\"(\\d{4})/(\\d{2})/(\\d{2})\" #pattern to match a date in the format YYYY/MM/DD\n",
        "match_data = re.search(pattern, url1) #find the the date pattern in the URL\n",
        "\n",
        "# match_data.group() returns the entire matched string (the full date)\n",
        "# match_data.group(1) returns the first capturing group (the year)\n",
        "# match_data.group(2) returns the second capturing group (the month)\n",
        "# match_data.group(3) returns the third capturing group (the day)\n",
        "print(f\"DATE   : {match_data.group()}\\nYEAR   : {match_data.group(1)}\\nMONTH  : {match_data.group(2)}\\nDAY    : {match_data.group(3)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F9Tlhxzs7yUi",
        "outputId": "38fb6ab3-0220-4df7-a106-2f9b4dcb631b"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DATE   : 2016/09/02\n",
            "YEAR   : 2016\n",
            "MONTH  : 09\n",
            "DAY    : 02\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#10. Write a Python program to find URLs in a string."
      ],
      "metadata": {
        "id": "7btpYgSIA3mC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = '<p>Contents :</p><a href=\"https://w3resource.com\">Python Examples</a><a href=\"http://github.com\">Even More Examples</a>'\n",
        "pattern = r\"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+\"\n",
        "url_list = re.findall(pattern, text)\n",
        "for url in url_list :\n",
        "    print(url)\n",
        "\n",
        "\n",
        "# http[s]?: Matches \"http\" or \"https\".\n",
        "# s?: Matches an optional \"s\" for HTTPS.\n",
        "# ://: Matches \"://\".\n",
        "# (?: ... )+: Non-capturing group that matches one or more of the following:\n",
        "# [a-zA-Z]: Matches any letter (case-insensitive).\n",
        "# [0-9]: Matches any digit.\n",
        "# [$-_@.&+]: Matches any of the characters in the set (dollar sign, hyphen, underscore, at symbol, dot, ampersand, plus).\n",
        "# [!*\\\\(\\\\),]: Matches any of the characters in the set (exclamation mark, asterisk, backslashes, parentheses, comma).\n",
        "# (?:%[0-9a-fA-F][0-9a-fA-F]): Matches percent-encoded characters (e.g., %20 for a space).\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eO6ijxZIA-28",
        "outputId": "3326a1ef-9c43-4096-92d2-ede4ae8756c3"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://w3resource.com\n",
            "http://github.com\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#11. Write a Python program to remove the parenthesis area in a string.\n",
        "\n",
        "Sample data : [\"example (.com)\", \"w3resource\", \"github (.com)\", \"stackoverflow (.com)\"] \\\n",
        "Expected Output: \\\n",
        "example  \\\n",
        "w3resource \\\n",
        "github  \\\n",
        "stackoverflow. \\"
      ],
      "metadata": {
        "id": "UNyH7NRCL1RS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "sample_data = [\"example (.com)\", \"w3resource\", \"github (.com)\", \"stackoverflow (.com)\"]\n",
        "pattern = r\"\\(.*?\\)\"    # pattern to match content inside parentheses (including the parentheses)\n",
        "                        # \\( and \\): Matches the opening and closing parentheses.\n",
        "                        # .*?: Matches any character (except for a newline) between the parentheses.\n",
        "for data in sample_data : # Loop through each string in the sample_data\n",
        "    print(re.sub(pattern,\"\",data)) # replace match with empty string to remove parentheses area\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "07YFw4f-LyCy",
        "outputId": "7930b19b-e22d-4b9a-b00e-c7cfcefd6569"
      },
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "example \n",
            "w3resource\n",
            "github \n",
            "stackoverflow \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#12. Write a Python program to concatenate the consecutive numbers in a given string.\n",
        "\n",
        "Original string:  \\\n",
        "Enter at 1 20 Kearny Street. The security desk can direct you to floor 1 6. Please have your identification ready.  \\\n",
        "\n",
        "After concatenating the consecutive numbers in the said string:  \\\n",
        "Enter at 120 Kearny Street. The security desk can direct you to floor 16. Please have your identification ready."
      ],
      "metadata": {
        "id": "d5avL_Kfm60m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "original_string = \"Enter at 1 20 Kearny Street. The security desk can direct you to floor 1 6. Please have your identification ready.\"\n",
        "\n",
        "# defines the regular expression pattern to match digit sequences.\n",
        "pattern = r\"\\d{1,}[\\s\\d{1,}]*\"\n",
        "\n",
        "# finds all occurrences of the pattern in the original string and iterates over them.\n",
        "# for each matched digit sequence, replaces it with the same sequence but without spaces.\n",
        "for digit in re.findall(pattern,original_string):\n",
        "    original_string = re.sub(digit.strip(), re.sub(r'\\s','',digit.strip()), original_string) # (pattern = digit.strip(), repl = re.sub(r'\\s','',digit.strip()), string = original_string)\n",
        "print(original_string)\n",
        "\n",
        "\n",
        "# Notes\n",
        "# The strip() method is used to remove any leading or trailing whitespace from the matched digit sequences before replacing them. This ensures that the replacement is done correctly.\n",
        "# The re.sub(r'\\s','',digit.strip()) call is used to remove spaces from the matched digit sequence before replacing it in the original string."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zn85THn6nRv0",
        "outputId": "d4710d57-7cf7-4e44-d9ff-3f9ef3767036"
      },
      "execution_count": 250,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter at 120 Kearny Street. The security desk can direct you to floor 16. Please have your identification ready.\n"
          ]
        }
      ]
    }
  ]
}