Regex_Tutorials.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "authorship_tag": "ABX9TyP5SlJa3xPjG7F0JXaYeQnE",
      "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/epythonlab/PythonLab/blob/master/Regex_Tutorials.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Learn Regular Expressions from Beginner to Advanced\n",
        "----\n",
        "<h2 style=\"margin-left:230px;\"><a href=\"https://telegram.me/epythonlab/\">Join Epythonlab</a></h2>\n",
        "\n",
        "----"
      ],
      "metadata": {
        "id": "vm3W_EvQn88u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Description:"
      ],
      "metadata": {
        "id": "fRUptFrZoFLG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this tutorial, you will learn everything you need to know about regular expressions, from beginner to advanced. I will cover the basics of regular expressions, as well as more advanced topics with practical examples. By the end of this tutorial, you will be able to use regular expressions to solve a variety of problems.\n",
        "\n",
        "Keywords\n",
        "\n",
        "regular expressions, regex, beginner, advanced, Python, programming, tutorial, regex tutorial, regular expressions tutorial, regex examples, regex exercises, beginner regex, advanced regex"
      ],
      "metadata": {
        "id": "w0476gLZoLms"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " # I. Introduction to Regular Expressions\n"
      ],
      "metadata": {
        "id": "6-we6O_KoTk_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A. What are regular expressions?\n",
        "- Regular expressions `(regex)` are sequences of characters that define a search pattern.\n",
        "- They are widely used for pattern matching and text manipulation tasks.\n",
        "\n",
        "B. Why are regular expressions useful?\n",
        "- Regular expressions offer a powerful and flexible way to search, validate, and manipulate text data.\n",
        "- They can be applied in various programming languages, text editors, and command-line tools.\n",
        "\n",
        "C. How are regular expressions applied in various fields?\n",
        "- Regular expressions find applications in fields like data validation, web scraping, text mining, log analysis, search and replace operations, and more."
      ],
      "metadata": {
        "id": "SofuEK09oo2e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# II. Regex Basics\n"
      ],
      "metadata": {
        "id": "uQ3XXEabpUnX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Importing the `re` Module\n",
        "\n",
        "In Python, regular expressions are handled using the built-in `re` module. Before using regular expressions, you need to import this module"
      ],
      "metadata": {
        "id": "O_nI9p-KKTXF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "SP3CLD8_Q0Zh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re"
      ],
      "metadata": {
        "id": "aNVVbxkmKgpE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `re` module provides a set of functions that allow you to work with regex\n",
        "\n",
        "- `re.match(pattern, string, flags=0)`: This function attempts to match the pattern only at the beginning of the string. If the pattern matches, it returns a match object; otherwise, it returns None. Use this function if you want to check whether a pattern occurs at the beginning of a string.\n",
        "\n",
        "- `re.search(pattern, string, flags=0)`: This function searches the entire string for a match to the pattern. It returns the first match found as a match object. If no match is found, it returns None. Use this function when you want to find the first occurrence of a pattern anywhere in the string.\n",
        "\n",
        "- `re.findall(pattern, string, flags=0)`: This function finds all non-overlapping occurrences of the pattern in the string and returns them as a list of substrings. If no matches are found, it returns an empty list. Use this function when you want to find all instances of a pattern in the string.\n",
        "\n",
        "- `re.finditer(pattern, string, flags=0)`: This function is similar to re.findall(), but instead of returning a list of substrings, it returns an iterator of match objects. Each match object contains information about the matched substring, such as the start and end indices.\n",
        "\n",
        "- `re.sub(pattern, replacement, string, count=0, flags=0)`: This function replaces all occurrences of the pattern in the string with the specified replacement. It returns a new string with the substitutions. The count parameter specifies the maximum number of substitutions to make (default is 0, which means all occurrences are replaced).\n",
        "\n",
        "- `re.split(pattern, string, maxsplit=0, flags=0)`: This function splits the input string by occurrences of the pattern and returns a list of substrings. The maxsplit parameter specifies the maximum number of splits to perform (default is 0, which means all occurrences are split).\n",
        "\n",
        "These functions are the core tools provided by the `re` module to work with regular expressions in Python. They allow you to perform various operations, such as searching, matching, replacing, and splitting strings based on complex patterns. Regular expressions are very powerful, and mastering their use can greatly enhance your string manipulation capabilities."
      ],
      "metadata": {
        "id": "8tQrr4zwQ2Ns"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A. Literal Matches\n",
        "- Matching literal characters directly.\n",
        "\n",
        "### Example:\n",
        "- The regex pattern `cat` matches the word \"cat\" in the input text."
      ],
      "metadata": {
        "id": "-xX36D_UKaLR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"The cat is on the mat.\"\n",
        "pattern = \"cat\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['cat']"
      ],
      "metadata": {
        "id": "Qu89KG2lo-8y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `re.findall(pattern, string)`: Returns all non-overlapping matches of the pattern in the string as a list."
      ],
      "metadata": {
        "id": "V4kcFIXaMcwr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## B. Metacharacters and Escaping\n",
        "- Special characters in regex that have a predefined meaning. Escaping them allows treating them as literal characters.\n",
        "### Example:\n",
        "- To match a dot `(.)`, you need to escape it like `\\.`"
      ],
      "metadata": {
        "id": "YCeRQDiAqLiS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"I have a dot in my sentence.\"\n",
        "pattern = r\"\\.\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['.']"
      ],
      "metadata": {
        "id": "GC8uaiQjqY27"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `. (dot)`: Matches any single character except a newline."
      ],
      "metadata": {
        "id": "2FfF73yjMpqa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## C. Character Classes and Ranges\n",
        "- Matching a specific set of characters or ranges.\n",
        "### Example:\n",
        "- The regex pattern `[aeiou]` matches any vowel in the input text."
      ],
      "metadata": {
        "id": "Wb8M8LjtqZhW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"I love apples and oranges.\"\n",
        "pattern = \"[aeiou]\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['o', 'e', 'a', 'e', 'o', 'a', 'o', 'e']"
      ],
      "metadata": {
        "id": "uyOS4fhlqlPS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `[ ] (square brackets)`: Matches any character within the brackets."
      ],
      "metadata": {
        "id": "x7dwzOJGtfDZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## D. Quantifiers\n",
        "- Specifying the number of occurrences of a character or group.\n",
        "### Example:\n",
        "- The regex pattern `a{2,4}` matches \"aa,\" \"aaa,\" or \"aaaa.\"\n"
      ],
      "metadata": {
        "id": "_syGOUuuqvmn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"aaa ab aab aaab\"\n",
        "pattern = \"a{2,4}b\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['aab', 'aaab']"
      ],
      "metadata": {
        "id": "6vAzaP_Aq4F0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `a{2,4}`: Matches the character \"a\" repeated 2 to 4 times consecutively.\n",
        "- `b`: Matches the character \"b\" immediately following the \"a\" sequence.\n",
        "Here's a breakdown of the pattern:\n",
        "\n",
        "- `a{2,4}`: The curly braces `{2,4}` indicate a quantifier.\n",
        " In this case, it specifies that the preceding character \"a\" should occur between 2 and 4 times. So, it will match patterns like \"aa\", \"aaa\", or \"aaaa\", but not \"a\" or \"aaaaa\".\n",
        "- `b`: Matches the character \"b\" immediately following the \"a\" sequence. It ensures that the pattern ends with the character \"b\"."
      ],
      "metadata": {
        "id": "Q6yH_V0CNeIH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## E. Anchors\n",
        "- Matching specific positions in the input text.\n",
        "### Example:\n",
        "- The regex pattern `^start` matches \"start\" at the beginning of a line."
      ],
      "metadata": {
        "id": "LjXGGSd6q4xk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Start with a newline\\nstart with a word\"\n",
        "pattern = \"^start\"\n",
        "\n",
        "result = re.findall(pattern, text, re.MULTILINE)\n",
        "print(result)  # Output: ['start']"
      ],
      "metadata": {
        "id": "vQeAUZqVq-xo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# III. Intermediate Regex Concepts\n"
      ],
      "metadata": {
        "id": "Ld0TfSawsMFk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A. Alternation\n",
        "- Matching multiple alternatives using the OR operator `(|)`.\n",
        "### Example:\n",
        "- The regex pattern `apple|orange` matches either \"apple\" or \"orange.\"\n"
      ],
      "metadata": {
        "id": "GLSKSkHQsQwE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"I have an apple and an orange.\"\n",
        "pattern = \"apple|orange\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['apple', 'orange']"
      ],
      "metadata": {
        "id": "j4V68xqGsZrc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `|(pipe)`: Matches either the expression before or after the pipe."
      ],
      "metadata": {
        "id": "fLjYnD5i1rcn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## B. Grouping and Capturing\n",
        "-  Grouping parts of a regex pattern and capturing matched substrings.\n",
        "###  Example:\n",
        "- The regex pattern `(ab)+` matches \"ab,\" \"abab,\" or \"ababab.\"\n"
      ],
      "metadata": {
        "id": "6t2bnGgrsZ_8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "text = \"abab abc ab\"\n",
        "pattern = \"(ab)+\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['ab', 'ab', 'ab']"
      ],
      "metadata": {
        "id": "OAQBO8lWsgXl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `* (asterisk)`: Matches zero or more occurrences of the preceding character or group.\n",
        "- `+ (plus)`: Matches one or more occurrences of the preceding character or group."
      ],
      "metadata": {
        "id": "yLvueJ7d2Ooa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## C. Backreferences\n",
        "-  Referring to previously captured groups within the same regex pattern.\n",
        "### Example:\n",
        "- The regex pattern `(\\d{2})-\\1` matches \"22-22\" but not \"22-33.\"\n"
      ],
      "metadata": {
        "id": "IYSfPJJusgk7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"22-22 22-33\"\n",
        "pattern = r\"(\\d{2})-\\1\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['22']"
      ],
      "metadata": {
        "id": "4VAjF5WsssJh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `\\d` matches any digit\n",
        "- `{2}` specifies that the preceding expression should occur exactly two times.\n",
        "- `-` matches a hyphen.\n",
        "- `\\1` ensures that the second occurrence of the same two-digit sequence is required, which is not present in the text.\n",
        "\n",
        "The regular expression pattern `r\"(\\d{2})-\\1\"` matches two consecutive digits followed by a hyphen, and then matches the same two-digit sequence again. It can be used to find repeated digit patterns separated by a hyphen."
      ],
      "metadata": {
        "id": "ZmTP3_LH236R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## D. Lookaheads and Lookbehinds\n",
        "- Matching based on the presence or absence of certain patterns ahead or behind the current position.\n",
        "### Example:\n",
        "- The regex pattern `(?<=prefix)\\w+` matches a word preceded by the word \"prefix.\"\n"
      ],
      "metadata": {
        "id": "cFyIaa2UssVz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"prefixword suffix\"\n",
        "pattern = r\"\\w+(?<=prefix)\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['word']"
      ],
      "metadata": {
        "id": "o7LMrF1ZsyRD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `\\w` matches any word character (alphanumeric and underscore).\n",
        "- `? (question mark)`: Matches zero or one occurrence of the preceding character or group.\n"
      ],
      "metadata": {
        "id": "GRy3xxI-tKZS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## E. Greedy vs. Lazy Matching\n",
        "- Controlling the matching behavior to be either greedy `(`matches as much as possible`)` or lazy `(`matches as little as possible`)`.\n",
        "### Example:\n",
        "- The regex pattern `a.+b` matches \"aabbbb\" in \"aaabbbbbaabbbb\" greedily, but \"aab\" lazily."
      ],
      "metadata": {
        "id": "bojCZGFRsypE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"aaabbbbbaabbbb\"\n",
        "pattern = r\"a.+b\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['aabbbbbaabbbb']\n",
        "\n"
      ],
      "metadata": {
        "id": "xSauOGn0s8Rj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pattern = r\"a.+?b\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['aab']"
      ],
      "metadata": {
        "id": "wX0UiYmWGqRK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `a`: Matches the character \"a\" literally.\n",
        "- `.+?`: Matches one or more occurrences of any character (except a newline) in a non-greedy fashion.\n",
        "- The `+` symbol means one or more occurrences, and the `?` symbol makes it non-greedy, meaning it will match as few characters as possible.\n",
        "- `b`: Matches the character \"b\" literally."
      ],
      "metadata": {
        "id": "VpyrE4fQIjpQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# IV. Advanced Regex Techniques\n"
      ],
      "metadata": {
        "id": "WtdxD7SOs8gH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A. Advanced Character Classes\n",
        "- Utilizing advanced character class constructs for matching specific character types.\n",
        "### Example:\n",
        "-The regex pattern `\\p{L}` matches any Unicode letter.\n"
      ],
      "metadata": {
        "id": "id7WlQD105Ie"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Hello, こんにちは, مرحبًا\"\n",
        "pattern = r\"\\w\"\n",
        "\n",
        "result = re.findall(pattern, text, re.UNICODE)\n",
        "print(result)  # Output: ['H', 'e', 'l', 'l', 'o', 'こ', 'ん', 'に', 'ち', 'は', 'م', 'ر', 'ح', 'ب', 'ا']\n"
      ],
      "metadata": {
        "id": "O5TRndQ41BFz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `\\p{L}`: This is a Unicode property escape that matches any Unicode letter character. It includes letters from all scripts, such as Latin, Cyrillic, Arabic, Chinese, etc.\n",
        "- the `re` module doesn't support Unicode properties using the `\\p{}` syntax directly. However, you can achieve the same functionality using the `re.UNICODE` flag (or `re.U` for short) in combination with the `\\w` shorthand character class."
      ],
      "metadata": {
        "id": "Oe-Q0ps6BTry"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## B. Modifiers and Flags\n",
        "- Adding modifiers or flags to change regex behavior (e.g., case-insensitive matching).\n",
        "### Example:\n",
        "- The regex pattern `pattern(?i)` matches \"pattern\" case-insensitively.\n"
      ],
      "metadata": {
        "id": "iZOhxLKy1BaI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Pattern matching using the pattern flag (?i)\"\n",
        "pattern = r\"pattern(?i)\"\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "print(matches)  # Output: ['Pattern', 'pattern']"
      ],
      "metadata": {
        "id": "x--lqu-31MYz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `pattern`: This part of the pattern matches the word \"pattern\" literally. It is case-sensitive by default.\n",
        "\n",
        "- `(?i)`: This is a flag that modifies the behavior of the regular expression. The `i` flag stands for \"ignore case,\" and when included in the pattern, it makes the pattern case-insensitive. It means that the pattern will match \"pattern,\" \"Pattern,\" \"PATTERN,\" and any other variation of the word regardless of its letter casing.\n",
        "\n"
      ],
      "metadata": {
        "id": "pUxNJm2IC7Ol"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## C. Conditional Matching\n",
        "-  Matching patterns conditionally based on certain criteria.\n",
        "### Example:\n",
        "- The regex pattern `(?(expression)true|false)` matches \"true\" if the expression is satisfied; otherwise, it matches \"false.\"\n"
      ],
      "metadata": {
        "id": "5-MAKMQx1MzL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"There are 10 items.\"\n",
        "pattern = r\"((10)?true|false)\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['true']"
      ],
      "metadata": {
        "id": "o4_Lyxes1UA7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `(?(10) ... )`: This is the conditional construct in the regular expression. It checks if the capture group numbered 10 exists.\n",
        "\n",
        "- `true`: If the capture group numbered 10 exists in the text, this part of the pattern matches and returns \"true.\"\n",
        "\n",
        "- `false`: If the capture group numbered 10 does not exist in the text, this part of the pattern matches and returns \"false.\""
      ],
      "metadata": {
        "id": "CDpjdFnlDQtT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## D. Recursive Patterns\n",
        "-  Creating patterns that can match nested or repetitive structures.\n",
        "### Example:\n",
        "- The regex pattern `(?R)` matches the entire pattern recursively.\n"
      ],
      "metadata": {
        "id": "1CjFfYDi1UPL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Nested brackets: (((text)))\"\n",
        "pattern = r\"(\\(((?>[^()]+|(?1))*)\\))\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: [('(((text)))', 'text')]"
      ],
      "metadata": {
        "id": "0utJ-_rA1aQv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## E. Assertions\n",
        "-  Making assertions about the surrounding text without including it in the actual match.\n",
        "### Example:\n",
        "- The regex pattern `word(?=\\W|$)` matches \"word\" only if it's followed by a non-word character or end of line."
      ],
      "metadata": {
        "id": "5sHJP3UG1ad8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"word, word1, word2\"\n",
        "pattern = r\"word(?=\\W|$)\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['word']"
      ],
      "metadata": {
        "id": "zPMTrX3D1gTO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `word`: Matches the characters \"word\" literally.\n",
        "\n",
        "- `(?=\\W|$)`: This is a positive lookahead assertion that ensures the presence of a non-word character `(\\W)` or the end of the string `($)` immediately after the word \"word\".\n",
        "- The `(?=...)` construct is used for lookahead assertions, and `\\W` represents any non-word character."
      ],
      "metadata": {
        "id": "E4KIe8_LwjIW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# V. Practical Examples and Demo Exercises\n"
      ],
      "metadata": {
        "id": "iObKT17y1go0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A. Validating Email Addresses\n",
        "- Using regex to validate the format of an email address.\n",
        "### Exercise:\n",
        "- Write a regex pattern to validate email addresses with the format \"username@epythonlab.com.\"\n"
      ],
      "metadata": {
        "id": "1lZ16eeOG05k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "emails = [\n",
        "    \"john_doe@example.com\",\n",
        "    \"alice123@mydomain.org\",\n",
        "    \"support@website\",\n",
        "    \"invalid-email\",\n",
        "    \"admin@com\",\n",
        "]\n",
        "pattern = r\"^\\w+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}$\"\n",
        "\n",
        "for email in emails:\n",
        "    if re.match(pattern, email):\n",
        "        print(f\"{email} is a valid email address.\")\n",
        "    else:\n",
        "        print(f\"{email} is not a valid email address.\")"
      ],
      "metadata": {
        "id": "vCFN8XkTG_T9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `^`: The caret symbol indicates the start of the string.\n",
        "\n",
        "- `\\w+`: This part of the pattern matches one or more word characters (letters, digits, or underscores). It matches the username part of the email address.\n",
        "\n",
        "- `@`: Matches the \"@\" symbol.\n",
        "\n",
        "- `[a-zA-Z_]+?`: This part matches one or more letters (both uppercase and lowercase) and underscores. The `+?` makes it non-greedy, meaning it matches as few characters as possible. It represents the domain name part of the email address.\n",
        "\n",
        "- `\\.`: Escapes the period (dot) character so that it matches a literal dot in the email address.\n",
        "\n",
        "- `[a-zA-Z]{2,3}`: This part matches two or three letters (both uppercase and lowercase). It represents the top-level domain (TLD) part of the email address, like \".com\" or \".org\".\n",
        "\n",
        "- `$`: The dollar sign indicates the end of the string."
      ],
      "metadata": {
        "id": "B8talOQdEKBs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## B. Extracting URLs from Text\n",
        "- Extracting URLs from a text document using regex.\n",
        "### Exercise:\n",
        "- Write a regex pattern to extract URLs from a given text input.\n"
      ],
      "metadata": {
        "id": "2nDPa9_CG_gT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Visit my website at https://www.example.com\"\n",
        "pattern = r\"https?://[\\w./-]+\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: ['https://www.example.com']"
      ],
      "metadata": {
        "id": "p6UMnWsyHEZF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `https?://`: This part matches \"http://\" or \"https://\". The `s?` makes the \"s\" optional, so it will match both \"http://\" and \"https://\".\n",
        "\n",
        "- `[\\w./-]+`: This part matches one or more occurrences of word characters, dots, slashes, and hyphens.\n",
        "  - The `\\w` is a shorthand character class for word characters (letters, digits, and underscores).\n",
        "  - The square brackets `[]` define a character class, which allows any character inside it.\n",
        "  - The character class includes `\\w` (word characters), `.` (dot), `/` (forward slash), and `-` (hyphen)."
      ],
      "metadata": {
        "id": "f0h0YHwKKwx2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## C. Parsing HTML/XML Tags\n",
        "- Parsing and extracting information from HTML/XML tags using regex.\n",
        "### Exercise:\n",
        "- Write a regex pattern to extract the content within HTML `<title>` tags.\n"
      ],
      "metadata": {
        "id": "_Xd1Y1SwHEr_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "html = \"<html><head><title>Regex tutorial</title></head><body><h1>This is regex tutorial home page</h1></body></html>\"\n",
        "pattern = r\"<title>(.*?)<\\/title>\"\n",
        "\n",
        "match = re.search(pattern, html)\n",
        "if match:\n",
        "    title_content = match.group(1)\n",
        "    print(f\"The title is: {title_content}\")\n",
        "else:\n",
        "    print(\"Title not found.\")\n"
      ],
      "metadata": {
        "id": "ecKYz-wvHLnO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `<title>`: this part mathces the opening title tag literally. It looks for the substring `\"</title>\"` in the text.\n",
        "\n",
        "- `(.*?)`: This is a non-greedy capture group enclosed in parentheses. The `.*?` matches any character (except a newline) zero or more times in a non-greedy manner. The non-greedy behavior means it will match as few characters as possible. This group is used to capture the content within the title tags.\n",
        "\n",
        "- `<\\/title>`: This part matches the closing title tag literally. The backslash `\\` is used to escape the forward slash, making sure it matches the actual `\"</title>\"` in the text."
      ],
      "metadata": {
        "id": "dPY8AERzGB6-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `re.search()` is a function provided by the Python re module, which is used for searching a string for a match to a regular expression pattern. It scans the entire input string and tries to find the first location where the pattern matches.\n",
        "- `pattern`: The regular expression pattern that you want to search for in the string.\n",
        "- `string`: The input string in which you want to search for the pattern.\n",
        "- `flags`: (Optional) Additional flags that modify the behavior of the regular expression. For example, `re.IGNORECASE` makes the pattern case-insensitive."
      ],
      "metadata": {
        "id": "YgXJcl2dQWpG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## D. Formatting and Manipulating Text\n",
        "- Using regex to format and manipulate text strings.\n",
        "### Exercise:\n",
        "- Write a regex pattern to remove all non-alphanumeric characters from a given text.\n"
      ],
      "metadata": {
        "id": "SZfimdK4HLyu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Remove!@#$non-alphanumeric%^characters\"\n",
        "pattern = r\"\\W+\"\n",
        "\n",
        "result = re.sub(pattern, \"\", text)\n",
        "print(result)  # Output: 'Removenonalphanumericcharacters'"
      ],
      "metadata": {
        "id": "kEmbaYOrHQB7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## E. Data Extraction and Transformation\n",
        "-  Applying regex to extract and transform data from structured or semi-structured text.\n",
        "### Exercise:\n",
        "- Write a regex pattern to extract phone numbers from a text document."
      ],
      "metadata": {
        "id": "HG6WB7YRHQNs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Contact us at: Phone: 123-456-7890 Email: info@example.com\"\n",
        "pattern = r\"Phone: (\\d{3}-\\d{3}-\\d{4}) Email: (\\w+@\\w+\\.\\w+)\"\n",
        "\n",
        "result = re.findall(pattern, text)\n",
        "print(result)  # Output: [('123-456-7890', 'info@example.com')]"
      ],
      "metadata": {
        "id": "tp9AmyQWHUgu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `Phone`:: This part matches the word \"Phone:\" literally. It will look for the substring \"Phone:\" in the text.\n",
        "\n",
        "- `(\\d{3}-\\d{3}-\\d{4})`: This is a capture group enclosed in parentheses. It matches a phone number in the format \"xxx-xxx-xxxx,\" where \"x\" represents any digit. The `\\d` is a shorthand character class for digits `(0-9)`. The curly braces `{3}` specify that the preceding digit pattern `\\d` should occur exactly three times.\n",
        "\n",
        "- `Email`:: This part matches the word \"Email:\" literally. It will look for the substring \"Email:\" in the text.\n",
        "\n",
        "- `(\\w+@\\w+\\.\\w+)`: This is another capture group enclosed in parentheses. It matches an email address in the format \"username@domain.com,\" where \"username\" can contain one or more word characters (letters, digits, or underscores), and \"domain.com\" can contain one or more word characters separated by a dot. The `\\w `is a shorthand character class for word characters, and `\\.` matches a literal dot."
      ],
      "metadata": {
        "id": "NXw3tff6FR4B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Conclusion:"
      ],
      "metadata": {
        "id": "j_Kd7syyJObZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "In conclusion, this comprehensive regex tutorial covered various topics from basics to advanced techniques. You learned how regex empowers you to tackle pattern matching and text manipulation tasks. With practical examples and exercises, you gained hands-on experience. Keep practicing and exploring the vast world of regex for endless possibilities in text-related problem-solving."
      ],
      "metadata": {
        "id": "zoyhbg_DIUQu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Join [Epythonlab](https://telegram.me/epythonlab/)"
      ],
      "metadata": {
        "id": "uIMGnhbwHUsO"
      }
    }
  ]
}