Assignment_7.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hr92-cyTyIo2"
      },
      "source": [
        "# Assignment_7\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "eCj29w_byuFR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.What is the name of the feature responsible for generating Regex objects?\n",
        "\n",
        "2.Why do raw strings often appear in Regex objects?\n",
        "\n",
        "3.What is the return value of the search() method?\n",
        "\n",
        "4.From a Match item, how do you get the actual strings that match the pattern?\n",
        "\n",
        "5.In the regex which created from the `r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)',` what does group zero cover? Group 2? Group 1?\n",
        "\n",
        "6.In standard expression syntax, parentheses and intervals have distinct meanings. How can you tell a regex that you want it to fit real parentheses and periods?\n",
        "\n",
        "7.The findall() method returns a string list or a list of string tuples. What causes it to return one of the two options?\n",
        "\n",
        "8.In standard expressions, what does the `|` character mean?\n",
        "\n",
        "\n",
        "9.In regular expressions, what does the `?` character stand for?\n",
        "\n",
        "\n",
        "10.In regular expressions, what is the difference between the + and * characters?\n",
        "\n",
        "11.What is the difference between `{4} and {4,5}` in regular expression?\n",
        "\n",
        "\n",
        "12.What do you mean by the \\d, \\w, and \\s shorthand character classes signify in regular expressions?\n",
        "\n",
        "\n",
        "13.What do means by `\\D, \\W, and \\S` shorthand character classes signify in regular expressions?\n",
        "\n",
        "14.What is the difference between `.*?` and `.*`?\n",
        "\n",
        "15.What is the syntax for matching both numbers and lowercase letters with a character class?\n",
        "\n",
        "\n",
        "16.What is the procedure for making a normal expression in regax case insensitive?\n",
        "\n",
        "17.What does the `. character` normally match? What does it match if `re.DOTALL` is passed as 2nd argument in `re.compile()`?\n",
        "\n",
        "\n",
        "18.If `numReg = re.compile(r'\\d+'), what will numRegex.sub('X', '11 drummers, 10 pipers, five rings, 4 hen')` return?\n",
        "\n",
        "\n",
        "19.What does passing `re.VERBOSE` as the 2nd argument to` re.compile()` allow to do?\n",
        "\n",
        "20.How would you write a regex that match a number with comma for every three digits? It must match the given following:\n",
        "\n",
        "- `'42','1,234', '6,368,745'`but not the following: `'12,34,567'` (which has only two digits between the commas) `'1234'` (which lacks commas)\n",
        "\n",
        "21.How would you write a regex that matches the full name of someone whose last name is Watanabe? You can assume that the first name that comes before it will always be one word that begins with a capital letter. \n",
        "\n",
        "- The regex must match the following:\n",
        "\n",
        "'Haruto Watanabe'\n",
        "\n",
        "'Alice Watanabe'\n",
        "\n",
        "'RoboCop Watanabe'\n",
        "\n",
        "\n",
        "- but not the following:\n",
        "\n",
        "`'haruto Watanabe' (where the first name is not capitalized)\n",
        "\n",
        "'Mr. Watanabe' (where the preceding word has a nonletter character)\n",
        "\n",
        "'Watanabe' (which has no first name)\n",
        "\n",
        "'Haruto watanabe' (where Watanabe is not capitalized)`\n",
        "\n",
        "\n",
        "22.How would you write a regex that matches a sentence where the first word is either Alice, Bob,or Carol; the second word is either eats, pets, or throws; the third word is apples, cats, or baseballs; and the sentence ends with a period? This regex should be case-insensitive. \n",
        "\n",
        "- It must match the following:\n",
        "\n",
        "'Alice eats apples.'\n",
        "\n",
        "'Bob pets cats.'\n",
        "\n",
        "'Carol throws baseballs.'\n",
        "\n",
        "'Alice throws Apples.'\n",
        "\n",
        "'BOB EATS CATS.'\n",
        "\n",
        "- but not the following:\n",
        "\n",
        "'RoboCop eats apples.'\n",
        "\n",
        "'ALICE THROWS FOOTBALLS.'\n",
        "\n",
        "'Carol eats 7 cats.'"
      ],
      "metadata": {
        "id": "ehyoG75x0L7N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Answer Sheet"
      ],
      "metadata": {
        "id": "h5MBJnKM2MOz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "i4WdpFfFywFR"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IAutDxUJyIpV"
      },
      "source": [
        "#### 1. What is the name of the feature responsible for generating Regex objects?\n",
        "\n",
        "**Ans:** **\n",
        "\n",
        "`re.compile()`** is the feature responsible for  generation of Regex objects."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZcEa5JvryIpY",
        "outputId": "5d046f90-87fe-48dd-8764-21a761996a90"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "re.compile('random_pattern')\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "x = re.compile(\"random_pattern\")\n",
        "type(x)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "yuGtTk2K60uH"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pMX7DcSXyIp2"
      },
      "source": [
        "#### 2. Why do raw strings often appear in Regex objects?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "Regular expressions use the backslash character `('\\')` to indicate special forms `(Metacharacters)` or to allow special characters `(speical sequences)` to be used  without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals. Hence, Raw strings are used (e.g. r\"\\n\") so that backslashes do not have to be escaped."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "HhBnUVYi63c0"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3dRdAIZHyIsc"
      },
      "source": [
        "#### 3. What is the return value of the search() method?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "The return value of `re.search(pattern,string)` method is a match object if the pattern is observed in the string else it returns a None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GvUaWUSkyIse",
        "outputId": "db5e53d8-f3bc-4c98-b8ae-c54f77e88bd6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Output: <re.Match object; span=(7, 8), match='i'>\n",
            "Output: None\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "match = re.search('i','Data Science Program Bootcamp 2.0', flags=re.IGNORECASE)\n",
        "print('Output:',match)\n",
        "match = re.search('X','Data Science Program Bootcamp 2.0', flags=re.IGNORECASE)\n",
        "print('Output:',match)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "cCLXAKD668fJ"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ZAQrFuuyIsp"
      },
      "source": [
        "#### *4*. From a Match item, how do you get the actual strings that match the pattern?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "For Matched items `group()` methods returns actual strings that match the pattern"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gkovhEqVyIss",
        "outputId": "80ea10e1-c1bb-43df-d3e4-9fed348bf0fa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Output: Python\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "match = re.search('python','Python Full Stack Data Science Program Bootcamo 2.0', flags=re.IGNORECASE)\n",
        "print('Output:',match.group())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "Gvn-Dh786-o0"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_L142zdHyIsv"
      },
      "source": [
        "#### 5. In the regex which created from the r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)', what does group zero cover? Group 2? Group 1?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "In the Regex **`r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)'`** the zero group covers the entire pattern match where as the first group cover **`(\\d\\d\\d)`** and the second group cover **`(\\d\\d\\d-\\d\\d\\d\\d)`**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mPg_4aVeyItL",
        "outputId": "f4b3cee0-76e0-49ad-f0e2-ec29abde5c93"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('105', '111-0000')\n",
            "105-111-0000\n",
            "105\n",
            "111-0000\n"
          ]
        }
      ],
      "source": [
        "# Example:\n",
        "\n",
        "import re\n",
        "phoneNumRegex = re.compile(r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)')\n",
        "mo = phoneNumRegex.search('My number is 105-111-0000.')\n",
        "print(mo.groups()) # Prints tuple format\n",
        "print(mo.group())  \n",
        "print(mo.group(1)) # Returns first group\n",
        "print(mo.group(2)) # Returns second group"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "hZCcz94X7-tE"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lxVsVf-XyItN"
      },
      "source": [
        "#### 6. In standard expression syntax, parentheses and intervals have distinct meanings. How can you tell a regex that you want it to fit real parentheses and periods?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "The **`\\.`** **`\\(`** and **`\\)`** escape characters in the raw string passed to re.compile() will match actual parenthesis characters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8ptOPbeQyItP",
        "outputId": "85f0b1ad-36fc-4bfb-d54c-cb710df321e4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(091) 8263-0506-58\n"
          ]
        }
      ],
      "source": [
        "# Example:\n",
        "\n",
        "import re\n",
        "phoneNumRegex = re.compile(r'(\\(\\d\\d\\d\\)) (\\d\\d\\d\\d-\\d\\d\\d\\d)-\\d\\d')\n",
        "mo = phoneNumRegex.search('My phone number is (091) 8263-0506-58.')\n",
        "print(mo.group())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "sa8R1jfk9qDC"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UaNaoab2yItR"
      },
      "source": [
        "#### 7. The findall() method returns a string list or a list of string tuples. What causes it to return one of the two options?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "If the regex pattern has no groups, a list of strings matched is returned. if the regex pattern has groups, a list of tuple of strings is returned."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fTBznVX_yItW",
        "outputId": "0600a460-328b-4109-a5b0-7fa8cd2526e1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('(091)', '8263-0506')]\n",
            "['091-8263-0506-58']\n"
          ]
        }
      ],
      "source": [
        "# Example:\n",
        "\n",
        "import re\n",
        "phoneNumRegex = re.compile(r'(\\(\\d\\d\\d\\)) (\\d\\d\\d\\d-\\d\\d\\d\\d)-\\d\\d')\n",
        "mo = phoneNumRegex.findall('My phone number is (091) 8263-0506-58.')\n",
        "print(mo)\n",
        "\n",
        "# Example:\n",
        "\n",
        "import re\n",
        "phoneNumRegex = re.compile(r'\\d{3}-\\d{4}-\\d{4}-\\d{2}')\n",
        "mo = phoneNumRegex.findall('My number is 091-8263-0506-58.')\n",
        "print(mo) # tuple format"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "QqnipStH-lRu"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KKPwQE29yItb"
      },
      "source": [
        "#### 8. In standard expressions, what does the | character mean?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "In Standard Expressions `|` means `OR` operator."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "J0KnpPVc-qKZ"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jmNQRGVyItc"
      },
      "source": [
        "#### 9. In regular expressions, what does the `?` character stand for?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "In regular Expressions, `?` characters represents zero or one match of the preceeding group."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IqcrYYtkyItd",
        "outputId": "c094d0c4-f724-4e28-deed-ad0bee25442f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<re.Match object; span=(0, 6), match='Batman'>\n"
          ]
        }
      ],
      "source": [
        "# Example:\n",
        "\n",
        "import re\n",
        "match_1 = re.search(\"Bat(wo)?man\",\"Batman returns\")\n",
        "print(match_1)\n",
        "#match_2 = re.search(\"Bat(wo)?man\",\"Batwoman returns\")\n",
        "#print(match_2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "match_2 = re.search(\"Bat(wo)?man\",\"Batwoman returns\")\n",
        "print(match_2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t2-p92-LHjiN",
        "outputId": "9dca42f6-9888-4f5d-a12b-5e9bcb14f030"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<re.Match object; span=(0, 8), match='Batwoman'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "0wPZ1wdaA8X9"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ky3mHhwtyIte"
      },
      "source": [
        "#### 10.In regular expressions, what is the difference between the + and * characters?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "In Regular Expressions, `*` Represents Zero ore more occurances of the preceeding group, whereas `+` represents one or more occurances of the preceeding group."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "82LAF6YryItf",
        "outputId": "b75e1f2f-8863-42c4-c26c-cb0fb3dd3f3a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<re.Match object; span=(0, 6), match='Batman'>\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "match_1 = re.search(\"Bat(wo)*man\",\"Batman returns\")\n",
        "print(match_1)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "match_2 = re.search(\"Bat(wo)+man\",\"Batman returns\")\n",
        "print(match_2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4LBmP8AuHzFD",
        "outputId": "2519911f-cdb4-4207-f82b-23e42d02e1f0"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "shdfUSB1IFwC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#regular expressions:\n",
        "\n",
        "import re\n",
        "match_1 = re.search(\"Bat(wo)*man\",\"Batman returns\")\n",
        "print(match_1)\n",
        "match_2 = re.search(\"Bat(wo)+man\",\"Batman returns\")\n",
        "print(match_2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g2ly03fxH9OJ",
        "outputId": "45c11e6d-4b9e-44fc-ef9d-e0cda40bf402"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<re.Match object; span=(0, 6), match='Batman'>\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "aW8D_dQABIF7"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kMiAuhqayItg"
      },
      "source": [
        "#### 11. What is the difference between {4} and {4,5} in regular expression?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "`{4}` means that its preceeding group should repeat 4 times. where as `{4,5}` means that its preceeding group should repeat mininum 4 times and maximum 5 times inclusively"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-SO5nf9zyIth",
        "outputId": "c3f29c9f-d267-4273-dfed-d4c08b881598"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EuEuEuEu\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "haRegex = re.compile(r'(Eu){4}')\n",
        "mo1 = haRegex.search('EuEuEuEu')\n",
        "mo2 = haRegex.search('Eu')\n",
        "print(mo1.group())\n",
        "print(mo2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "haRegex = re.compile(r'(Shu){4}')\n",
        "mo1 = haRegex.search('ShuShuShuShu')\n",
        "mo2 = haRegex.search('Shu')\n",
        "print(mo1.group())\n",
        "print(mo2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qIp_TQ66CaDk",
        "outputId": "fa17cdb0-9e81-412f-a4a3-ca9cb9eb7bc1"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ShuShuShuShu\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "2zititpJDBo7"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WsYsqPf4yItu"
      },
      "source": [
        "#### 12. What do you mean by the `\\d, \\w, and \\s` shorthand character classes signify in regular expressions?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "- \\d, \\w and \\s are special sequences in regular expresssions in python:\n",
        "1. **`\\w`** – Matches a word character equivalent to [a-zA-Z0-9_]\n",
        "2. **`\\d`** – Matches digit character equivalent to [0-9]\n",
        "3. **`\\s`** – Matches whitespace character (space, tab, newline, etc.)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "WIa1dCu0DaHZ"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3aJs4ix-yItv"
      },
      "source": [
        "#### 13. What do means by `\\D, \\W, and \\S`shorthand character classes signify in regular expressions?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "- \\D, \\W and \\S are special sequences in regular expresssions in python:\n",
        "1. **`\\W`** – Matches any non-alphanumeric character equivalent to [^a-zA-Z0-9_]\n",
        "2. **`\\D`** – Matches any non-digit character, this is equivalent to the set class [^0-9]\n",
        "3. **`\\S`** – Matches any non-whitespace character"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "s_frctAfDcx7"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "szFiIO3pyIt8"
      },
      "source": [
        "#### 14. What is the difference between `.*?` and `.*`?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "**`.*`** is a Greedy mode, which returns the longest string that meets the condition.\n",
        "\n",
        "Whereas **`.*?`** is a non greedy mode which returns the shortest string that meets the condition."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "wzSMlgKQDoSM"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ziNTUyw4yIt9"
      },
      "source": [
        "#### 15. What is the syntax for matching both numbers and lowercase letters with a character class?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "The Synatax is Either **`[a-z0-7]`** or **`[0-7a-z]`**"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "58nA-tfADzCU"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klhrLKulyIt-"
      },
      "source": [
        "#### 16. What is the procedure for making a normal expression in regax case insensitive?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "We can pass **`re.IGNORECASE`** as a flag to make a noraml expression case insensitive"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "hKDmYDgvD6Jb"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l8t4IVB3yIt-"
      },
      "source": [
        "#### 17. What does the `.` character normally match? What does it match if `re.DOTALL` is passed as 2nd argument in `re.compile()`?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "Dot **`.`** character matches everything in input except newline character **`.`**. By passing **`re.DOTALL`** as a flag to **`re.compile()`**, you can make the dot character match all characters, including the newline character."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "uA9sFD-jER7U"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "io6TxWYfyIyW"
      },
      "source": [
        "#### 18. If numReg = re.compile(r'\\d+'), what will numRegex.sub('X', '11 drummers, 10 pipers, five rings, 4 hen') return?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "The Ouput will be **`'X drummers, X pipers, five rings, X hen'`**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "EjQOcZ4PyIyX",
        "outputId": "ff4e6f1f-66e5-494f-afb3-3be4e6f21fbe"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'X drummers, X pipers, five rings, X hen'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 51
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "numReg = re.compile(r'\\d+')\n",
        "numReg.sub('X', '11 drummers, 10 pipers, five rings, 4 hen')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "WA0PeG8FI4_4"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0FMwHMqyIyZ"
      },
      "source": [
        "#### 19. What does passing re.VERBOSE as the 2nd argument to re.compile() allow to do?\n",
        "\n",
        "**Ans:** \n",
        "\n",
        "**`re.VERBOSE`** will allow to add whitespace and comments to string passed to **`re.compile()`**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "id": "VjObDIiNyIyZ"
      },
      "outputs": [],
      "source": [
        "#Example:\n",
        "\n",
        "# Without Using VERBOSE:\n",
        "\n",
        "regex_email = re.compile(r'^([a-z0-7_\\.-]+)@([0-7a-z\\.-]+)\\.([a-z\\.]{2, 6})$', re.IGNORECASE)\n",
        " \n",
        "\n",
        "# With Using VERBOSE:\n",
        "regex_email = re.compile(r\"\"\"\n",
        "                            ^([a-z0-7_\\.-]+)              # local Part like username\n",
        "                            @                             # single @ sign \n",
        "                            ([0-7a-z\\.-]+)                # Domain name like Google\n",
        "                            \\.                            # single Dot .\n",
        "                            ([a-z]{2,6})$                 # Top level Domain  like com/in/org\n",
        "                         \"\"\",re.VERBOSE | re.IGNORECASE)   "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "QI4h1xVUJf1M"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PKAxGQKQyIyf"
      },
      "source": [
        "#### 20. How would you write a regex that match a number with comma for every three digits? It must match the given following:\n",
        "\n",
        "`'42','1,234', '6,368,745'`but not the following: `'12,34,567'` (which has only two digits between the commas) `'1234'` (which lacks commas)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "62qZYkm7yIym",
        "outputId": "0949f609-a1b9-489e-8fc2-6872b5e3e3c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Output: 42 -> <re.Match object; span=(0, 2), match='42'>\n",
            "Output: 1,234 -> <re.Match object; span=(0, 5), match='1,234'>\n",
            "Output: 6,368,745 -> <re.Match object; span=(0, 9), match='6,368,745'>\n",
            "Output: 12,34,567 -> None\n",
            "Output: 1234 -> None\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "pattern = r'^\\d{1,3}(,\\d{3})*$'\n",
        "pagex = re.compile(pattern)\n",
        "for ele in ['42','1,234', '6,368,745','12,34,567','1234']:\n",
        "    print('Output:',ele, '->', pagex.search(ele))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "TTGKSqXOKC-m"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pIzdqer4yIyn"
      },
      "source": [
        "#### 21. How would you write a regex that matches the full name of someone whose last name is Watanabe? You can assume that the first name that comes before it will always be one word that begins with a capital letter. \n",
        "\n",
        "The regex must match the following:\n",
        "\n",
        "`'Haruto Watanabe'`  \n",
        "`'Alice Watanabe'`  \n",
        "`'RoboCop Watanabe'`  \n",
        "\n",
        "but not the following:\n",
        "\n",
        "`'haruto Watanabe'` (where the first name is not capitalized)  \n",
        "`'Mr. Watanabe'` (where the preceding word has a nonletter character)  \n",
        "`'Watanabe'` (which has no first name)  \n",
        "`'Haruto watanabe'` (where Watanabe is not capitalized)  \n",
        "\n",
        "**Ans:** \n",
        "\n",
        "**`pattern = r'[A-Z]{1}[a-z]*\\sWatanabe'`**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RjMrI4fRyIyo",
        "outputId": "5bcf8e46-a29d-42b5-daff-f10e669d7dc9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Output:  Haruto Watanabe -> <re.Match object; span=(0, 15), match='Haruto Watanabe'>\n",
            "Output:  Alice Watanabe -> <re.Match object; span=(0, 14), match='Alice Watanabe'>\n",
            "Output:  RoboCop Watanabe -> <re.Match object; span=(4, 16), match='Cop Watanabe'>\n",
            "Output:  haruto Watanabe -> None\n",
            "Output:  Mr. Watanabe -> None\n",
            "Output:  Watanabe -> None\n",
            "Output:  Haruto watanabe -> None\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "pattern = r'[A-Z]{1}[a-z]*\\sWatanabe'\n",
        "namex = re.compile(pattern)\n",
        "for name in ['Haruto Watanabe','Alice Watanabe','RoboCop Watanabe','haruto Watanabe','Mr. Watanabe','Watanabe','Haruto watanabe']:\n",
        "    print('Output: ',name,'->',namex.search(name))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "LGkhqKmFKpQ4"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h8dqpvRsyIyo"
      },
      "source": [
        "#### 22. How would you write a regex that matches a sentence where the first word is either Alice, Bob,or Carol; the second word is either eats, pets, or throws; the third word is apples, cats, or baseballs; and the sentence ends with a period? This regex should be case-insensitive. \n",
        "\n",
        "It must match the following:\n",
        "\n",
        "`'Alice eats apples.'`  \n",
        "`'Bob pets cats.'`  \n",
        "`'Carol throws baseballs.'`  \n",
        "`'Alice throws Apples.'`  \n",
        "`'BOB EATS CATS.'`  \n",
        "\n",
        "but not the following:  \n",
        "\n",
        "`'RoboCop eats apples.'`  \n",
        "`'ALICE THROWS FOOTBALLS.'`   \n",
        "`'Carol eats 7 cats.'`  \n",
        "\n",
        "**Ans:** \n",
        "\n",
        "pattern = **`r'(Alice|Bob|Carol)\\s(eats|pets|throws)\\s(apples|cats|baseballs)\\.'`**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JPFEfRT8yIyq",
        "outputId": "d1a22e7b-78a5-480a-c19c-978c8b20ca47"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Output:  Alice eats apples. -> <re.Match object; span=(0, 18), match='Alice eats apples.'>\n",
            "Output:  Bob pets cats. -> <re.Match object; span=(0, 14), match='Bob pets cats.'>\n",
            "Output:  Carol throws baseballs. -> <re.Match object; span=(0, 23), match='Carol throws baseballs.'>\n",
            "Output:  Alice throws Apples. -> <re.Match object; span=(0, 20), match='Alice throws Apples.'>\n",
            "Output:  BOB EATS CATS. -> <re.Match object; span=(0, 14), match='BOB EATS CATS.'>\n",
            "Output:  RoboCop eats apples. -> None\n",
            "Output:  ALICE THROWS FOOTBALLS. -> None\n",
            "Output:  Carol eats 7 cats. -> None\n"
          ]
        }
      ],
      "source": [
        "#Example:\n",
        "\n",
        "import re\n",
        "pattern = r'(Alice|Bob|Carol)\\s(eats|pets|throws)\\s(apples|cats|baseballs)\\.'\n",
        "casex = re.compile(pattern,re.IGNORECASE)\n",
        "for ele in ['Alice eats apples.','Bob pets cats.','Carol throws baseballs.','Alice throws Apples.','BOB EATS CATS.','RoboCop eats apples.'\n",
        ",'ALICE THROWS FOOTBALLS.','Carol eats 7 cats.']:\n",
        "    print('Output: ',ele,'->',casex.search(ele))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "rHKmQSViLAvF"
      }
    }
  ],
  "metadata": {
    "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.8"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}