regex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Regular Expressions (Regex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://miro.medium.com/max/2392/0*1-i9w0e4kklVQl5B.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "It is estimated that 80% of the data is **unstructured**\n",
    "\n",
    "And **unstructured** data is basically **text data**!\n",
    "\n",
    "Text is present in every major business process, from support tickets to product feedback and customer interactions.\n",
    "\n",
    "There is not doubt that text analysis has a broad range of business applications and use cases:\n",
    "* Understand customer \n",
    "* Risk managment\n",
    "* Prediction and prevention of crime\n",
    "* Personalized adversitsing\n",
    "* ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Introduction\n",
    "\n",
    "Regular Expressions, often abbreviated as Regex, are essential tools in data analytics for processing and manipulating textual data. Regex provides a method for searching and manipulating strings using a specialized syntax that defines patterns.\n",
    "\n",
    "## What is Regex?\n",
    "\n",
    "Regex is a sequence of characters that forms a search pattern. It can be used for performing various text processing tasks such as:\n",
    "\n",
    "- **Pattern Matching**: Searching for specific patterns within text.\n",
    "- **Data Validation**: Ensuring that data is in a correct format.\n",
    "- **Data Extraction**: Extracting specific portions from text based on patterns.\n",
    "- **Text Substitution**: Replacing parts of text using pattern matching.\n",
    "\n",
    "## Historical Context of Regular Expressions in Data Analytics\n",
    "\n",
    "Regular Expressions (Regex) have a rich history dating back to the 1950s, with foundational concepts developed by the American mathematician Stephen Kleene. This section aims to provide a deeper historical insight into Regex and its evolution in the context of data analytics.\n",
    "\n",
    "## The Origin of Regular Expressions\n",
    "\n",
    "- **Stephen Kleene's Contribution**: In 1956, Stephen Kleene introduced the concept of Regular Expressions in his paper \"Representation of Events in Nerve Nets and Finite Automata\" in the book \"Automata Studies\", edited by Claude Shannon and John McCarthy. This formalized the description of regular languages.\n",
    "- **Unix and Regex**: The widespread use of Regex began with Unix text processing utilities like `ed`, an editor, and `grep` (global regular expression print), a filter. These tools made Regex a fundamental part of text processing and pattern recognition in computing.\n",
    "\n",
    "## Regex in Computing\n",
    "\n",
    "- **Regular Expression Processor**: This processor translates a regular expression into a nondeterministic finite automaton (NFA), where several states can result from a given state and symbol. This automaton is then made deterministic (with only one possible state transition for a particular symbol) and is used to recognize substrings that match the regular expression.\n",
    "\n",
    "\n",
    "## The Role of Regex in Data Analytics\n",
    "\n",
    "In data analytics, Regex becomes particularly powerful in scenarios like:\n",
    "\n",
    "- **Text Data Preprocessing**: Cleaning and standardizing text data for analysis.\n",
    "- **Log File Analysis**: Parsing log files to extract relevant information.\n",
    "- **Natural Language Processing**: Identifying and manipulating linguistic patterns.\n",
    "- **Data Scraping**: Extracting information from unstructured data sources.\n",
    "\n",
    "## Regex Syntax and Operations\n",
    "\n",
    "Regex operations are based on a unique syntax that includes a variety of special characters and constructs. Some common elements include:\n",
    "\n",
    "- `.`: Matches any character\n",
    "- `*`: Zero or more occurrences\n",
    "- `+`: One or more occurrences\n",
    "- `?`: Zero or one occurrence\n",
    "- `[ ]`: A set of characters\n",
    "- `{ }`: A specific number of occurrences\n",
    "- `( )`: Capture and group\n",
    "\n",
    "## Resources and Further Reading\n",
    "\n",
    "For those new to Regex, or looking to deepen their understanding, the following resources can be invaluable:\n",
    "\n",
    "- [Regular Expressions Quick Start](https://www.regular-expressions.info/quickstart.html)\n",
    "- [RegexOne - Learn Regular Expressions with simple, interactive exercises](https://regexone.com/)\n",
    "- [Python's `re` Module Documentation](https://docs.python.org/3/library/re.html)\n",
    "\n",
    "By mastering Regex, data analysts can perform more sophisticated text analysis and data manipulation, enhancing their overall data analysis capabilities.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Importing the regular expression module from Python's standard library\n",
    "import re\n",
    "\n",
    "# Strings to be searched for matching regex patterns\n",
    "str1 = \"varks Aard belíng to the Captain\"\n",
    "str2 = \"Albert's famous equation, E = mc^2.\"\n",
    "str3 = \"Located at 455 Serra Mall.\"\n",
    "str4 = \"Beware of the shape-shifters!\"\n",
    "\n",
    "# Creating a list of strings to test regex patterns on\n",
    "test_strings = [str1, str2, str3, str4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The test string is \"varks Aard belíng to the Captain\"\n",
      "- The first possible match is: í\n",
      "\n",
      "The test string is \"Albert's famous equation, E = mc^2.\"\n",
      "- ** no match. **\n",
      "\n",
      "The test string is \"Located at 455 Serra Mall.\"\n",
      "- ** no match. **\n",
      "\n",
      "The test string is \"Beware of the shape-shifters!\"\n",
      "- ** no match. **\n"
     ]
    }
   ],
   "source": [
    "# Looping through each string in the test_strings list\n",
    "for test_string in test_strings:\n",
    "    # Printing the test string for reference\n",
    "    print('\\nThe test string is \"' + test_string + '\"')\n",
    "    \n",
    "    # Using re.search() to find the first location where the regex pattern '[í]' matches\n",
    "    # '[í]' is a regex pattern that searches for the character 'í' in the string\n",
    "    match = re.search('[í]', test_string)\n",
    "\n",
    "    # Checking if a match was found\n",
    "    if match:\n",
    "        # Printing the matched character if a match is found\n",
    "        # match.group() returns the part of the string where there is a match\n",
    "        print('- The first possible match is: ' + match.group())\n",
    "    else:\n",
    "        # Indicating that no match was found if the regex pattern doesn't match any part of the string\n",
    "        print('- ** no match. **')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's break down the code above line by line for better understanding:\n",
    "\n",
    "### 1. Iterating Over Each String in the List\n",
    "for test_string in test_strings:\n",
    "`test_strings` is a list containing multiple strings. In this `for` loop, we iterate over each element of the list. During each iteration, `test_string` refers to the current string being processed.\n",
    "\n",
    "### 2. Printing the Current Test String\n",
    "print('The test string is \"' + test_string + '\"')\n",
    "This line simply outputs the current string being examined in the loop. It helps in tracking which string the regex is being applied to.\n",
    "\n",
    "### 3. Searching for a Pattern in the String\n",
    "match = re.search(r'[A-Z]', test_string)\n",
    "Here, `re.search()` is used to find the first location within `test_string` where the regex pattern `[A-Z]` matches. This pattern looks for any uppercase letter from A to Z. The function returns an `SRE_Match` object if a match is found, and `None` if no match is found.\n",
    "\n",
    "### 4. Checking for a Match and Printing the Result\n",
    " `\n",
    "if match:\n",
    "    print('The first possible match is: ' + match.group())\n",
    "else:\n",
    "    print('no match.')\n",
    " `\n",
    "\n",
    "In this section, we check if `match` is an `SRE_Match` object or `None`. If it's `SRE_Match`, it means a match was found, and we print the matched substring using `match.group()`. `group()` is a method of `SRE_Match` objects that returns the part of the string where the match was found. If `match` is `None`, it implies no match was found, and we print a message stating so.\n",
    "\n",
    "### 5. Understanding the Behavior of `re.search()`\n",
    "- Single Character Match: Since the pattern `[A-Z]` is designed to match a single uppercase character, `re.search()` returns only the first matching character.\n",
    "- First Match Only: `re.search()` stops searching after finding the first match. It does not continue to look for further matches in the string.\n",
    "\n",
    "### 6. Alternative: Finding All Matches\n",
    "If the goal is to find all matches of a pattern in a string, `re.findall()` should be used instead. This function returns a list containing all the matches of the pattern in the string, not just the first one.\n",
    "matches = re.findall(r'[A-Z]', test_string)\n",
    "This would return a list of all uppercase characters found in `test_string`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As a recap of the test_string\n",
    "test_strings = [\n",
    "    \"varks Aard belíng to the Captain\",\n",
    "    \"Albert's famous equation, E = mc^2.\",\n",
    "    \"Located at 455 Serra Mall.\",\n",
    "    \"Beware of the shape-shifters!\"\n",
    "]\n",
    "\n",
    "# Looping through each string in the test_strings list\n",
    "for string in test_strings:\n",
    "    # Printing the current string\n",
    "    print(string)\n",
    "    \n",
    "    # Using re.findall to search for all occurrences of the regex pattern in the string\n",
    "    # The pattern '[A-Z]' matches any uppercase letter from A to Z\n",
    "    matches = re.findall(r'[A-Z]', string)\n",
    "    \n",
    "    # Printing the list of matches found in the current string\n",
    "    # Each match is an uppercase letter from the string\n",
    "    print(\"-\", matches, \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "When working with regular expressions in Python, you have the option to compile your regex patterns into pattern objects. This can improve performance, especially if you're going to use the same pattern multiple times. Precompilation turns your regex pattern into an `SRE_Pattern` object, which can then be used to perform match, search, and other operations.\n",
    "\n",
    "## Why Precompile Regex?\n",
    "\n",
    "- **Performance**: Compiling a pattern once and using it multiple times is more efficient than interpreting the same pattern repeatedly.\n",
    "- **Organization**: If you have multiple patterns, compiling them into objects helps keep your code organized.\n",
    "- **Reusability**: Once compiled, the same pattern object can be used in multiple match/search operations without recompilation.\n",
    "- **Legibility**: It allows you to assign descriptive names to your patterns, making your code more readable.\n",
    "\n",
    "## How to Precompile Regex Patterns\n",
    "\n",
    "Here's an example of how to precompile regex patterns in Python:\n",
    "\n",
    "```python\n",
    "import re\n",
    "\n",
    "# Precompile the pattern to match any uppercase letters\n",
    "pattern_uppercase = re.compile(r'[A-Z]')\n",
    "\n",
    "# Now you can use pattern_uppercase to search within strings\n",
    "match = pattern_uppercase.search('Hello World')\n",
    "if match:\n",
    "    print('Uppercase letter found:', match.group())\n",
    "```\n",
    "\n",
    "In this code, `re.compile` is used to compile the regex pattern `[A-Z]` which matches any uppercase letter. The resulting `pattern_uppercase` object can be used to search through strings without having to recompile the pattern each time, leading to more efficient execution, particularly when dealing with large amounts of text or many searches.\n",
    "\n",
    "You can even store multiple compiled patterns in a list and iterate over them, as shown in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the regex module\n",
    "import re\n",
    "\n",
    "# Define a list of regex patterns\n",
    "patterns = [\n",
    "    '[ABC]',                # Matches any one of 'A', 'B', or 'C'\n",
    "    '[^ABC]',               # Matches any character except 'A', 'B', or 'C'\n",
    "    '[ABC^]',               # Matches 'A', 'B', 'C', or '^'\n",
    "    '[0-9]',                # Matches any single digit from '0' to '9'\n",
    "    '[0-4]',                # Matches any single digit from '0' to '4'\n",
    "    '[A-Z]',                # Matches any uppercase letter from 'A' to 'Z'\n",
    "    '[a-z]',                # Matches any lowercase letter from 'a' to 'z'\n",
    "    '[A-Za-z]',             # Matches any letter regardless of case\n",
    "    '[A-Za-z0-9]',          # Matches any alphanumeric character\n",
    "    '[-a-z]',               # Matches '-' or any lowercase letter\n",
    "    '[- a-z]'               # Matches '-', space, or any lowercase letter\n",
    "]\n",
    "\n",
    "# Compile the patterns to create SRE_Pattern objects for efficient matching\n",
    "compiled_patterns = [re.compile(p) for p in patterns]\n",
    "\n",
    "# Function to find the first match of a pattern in a given string\n",
    "def find_match(compiled_pattern, string):\n",
    "    match = compiled_pattern.search(string)  # Perform the search using the compiled pattern\n",
    "    return match.group() if match else 'no match.'  # Return the matched text or 'no match.'\n",
    "\n",
    "# List of test strings to match against\n",
    "test_strings = [\n",
    "    \"ABC easy as 123\",\n",
    "    \"Simple as do re mi\",\n",
    "    \"ABC, 123, baby, you and me girl\"\n",
    "]\n",
    "\n",
    "# Iterate over each string in the test_strings list\n",
    "for test_string in test_strings:\n",
    "    # Print the test string for clarity\n",
    "    print(f\"In: \\\"{test_string}\\\"\")\n",
    "    # Find and print the first match for each compiled pattern\n",
    "    for compiled_pattern in compiled_patterns:\n",
    "        # Retrieve the pattern's string representation for the output\n",
    "        pattern_text = compiled_pattern.pattern\n",
    "        # Find the first match for the pattern in the current test string\n",
    "        match_text = find_match(compiled_pattern, test_string)\n",
    "        # Print the pattern and its first match (or 'no match.')\n",
    "        print(f' - The first potential match for \"{pattern_text}\" \\t is: {match_text}')\n",
    "    # Print a newline for better separation of output in the console\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Python script demonstrates how to use regular expressions (regex) to find patterns within strings. The comments in the code will help explain each step of the process.\n",
    "\n",
    "## Defining Regex Patterns\n",
    "\n",
    "We define a list of regex patterns. Each pattern is a string that specifies a rule for what constitutes a match:\n",
    "\n",
    "- `[ABC]`: Matches any one of 'A', 'B', or 'C'.\n",
    "- `[^ABC]`: Matches any character except 'A', 'B', or 'C'.\n",
    "- `[ABC^]`: Matches 'A', 'B', 'C', or '^'.\n",
    "- `[0-9]`: Matches any single digit from '0' to '9'.\n",
    "- `[0-4]`: Matches any single digit from '0' to '4'.\n",
    "- `[A-Z]`: Matches any uppercase letter from 'A' to 'Z'.\n",
    "- `[a-z]`: Matches any lowercase letter from 'a' to 'z'.\n",
    "- `[A-Za-z]`: Matches any letter regardless of case.\n",
    "- `[A-Za-z0-9]`: Matches any alphanumeric character.\n",
    "- `[-a-z]`: Matches '-' or any lowercase letter.\n",
    "- `[- a-z]`: Matches '-', space, or any lowercase letter.\n",
    "\n",
    "patterns = [...]\n",
    "\n",
    "## Compiling the Patterns\n",
    "\n",
    "Each pattern in the list is compiled for efficient matching. This is particularly useful when a pattern is used multiple times.\n",
    "\n",
    "`\n",
    "compiled_patterns = [re.compile(p) for p in patterns]\n",
    "`\n",
    "\n",
    "## Defining the `find_match` Function\n",
    "\n",
    "The `find_match` function searches for the first match of a compiled pattern within a given string. If a match is found, it returns the matched text; otherwise, it returns 'no match.'\n",
    "\n",
    "`\n",
    "def find_match(compiled_pattern, string):\n",
    "    ...\n",
    "`\n",
    "\n",
    "## Test Strings\n",
    "\n",
    "A list of test strings is defined, which will be searched for matches against the patterns.\n",
    "\n",
    "`\n",
    "test_strings = [...]\n",
    "`\n",
    "\n",
    "## Performing the Pattern Matching\n",
    "\n",
    "The script iterates over each string in `test_strings`, and for each string, it applies all the compiled regex patterns. For each pattern, it prints the first match found or 'no match.' if no match is found.\n",
    "\n",
    "`\n",
    "for test_string in test_strings:\n",
    "    print(f\"In: \\\"{test_string}\\\"\")\n",
    "    for compiled_pattern in compiled_patterns:\n",
    "        ...\n",
    "    print()\n",
    "`\n",
    "\n",
    "## Working with Lists of Compiled Patterns\n",
    "\n",
    "You can even store multiple compiled patterns in a list and iterate over them, as shown in the following example:\n",
    "\n",
    "`\n",
    "print(patterns[1])\n",
    "print(patterns[1].pattern)\n",
    "`\n",
    "\n",
    "In this section, we demonstrate how to access and use individual compiled patterns from the list. The `patterns[1]` expression references the second compiled pattern in the list. By printing `patterns[1].pattern`, we can see the actual regex pattern as a string.\n",
    "\n",
    "This process helps in identifying which part of the string matches the given patterns and is a practical way to learn and understand regex applications in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re  # Importing the regular expression module\n",
    "\n",
    "# Defining the string we are going to check\n",
    "needle = 'needlers'\n",
    "\n",
    "# Python approach: Using list comprehension and any()\n",
    "# This line checks if the string 'needle' ends with any of the specified suffixes ('ly', 'ed', 'ing', 'ers')\n",
    "# any() returns True if at least one of the conditions is True\n",
    "print(any([needle.endswith(e) for e in ('ly', 'ed', 'ing', 'ers')]))\n",
    "\n",
    "# On-the-fly Regular expression in Python\n",
    "# This uses regular expressions to check if 'needle' ends with the specified suffixes\n",
    "# The search() function looks through 'needle' for any match to the regular expression pattern\n",
    "# bool() is used to convert the result to True or False\n",
    "print(bool(re.search(r'(ly|ed|ing|ers)$', needle)))\n",
    "\n",
    "# Compiled Regular expression in Python\n",
    "# Compiling the regular expression pattern for faster reuse\n",
    "# This is more efficient if the pattern is used multiple times\n",
    "comp = re.compile(r'(ly|ed|ing|ers)$')\n",
    "print(bool(comp.search(needle)))\n",
    "\n",
    "# The %timeit commands are used in Jupyter Notebooks to measure the execution time of small code snippets\n",
    "# -n 1000 specifies that the command will run 1000 times in each loop\n",
    "# -r 50 indicates that there will be 50 such loops\n",
    "# This is used to get a more accurate measure of execution time by averaging over multiple runs\n",
    "\n",
    "# %timeit for the Python approach\n",
    "%timeit -n 1000 -r 50 bool(any([needle.endswith(e) for e in ('ly', 'ed', 'ing', 'ers')]))\n",
    "\n",
    "# %timeit for the on-the-fly regular expression\n",
    "%timeit -n 1000 -r 50 bool(re.search(r'(ly|ed|ing|ers)$', needle))\n",
    "\n",
    "# %timeit for the compiled regular expression\n",
    "%timeit -n 1000 -r 50 bool(comp.search(needle))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of terms for regular expressions\n",
    "\n",
    "### Regular Expressions Terminology\n",
    "\n",
    "Regular expressions (regex or regexp) are powerful tools for pattern matching and text manipulation. Here's a detailed explanation of some commonly used terms and symbols in regular expressions:\n",
    "\n",
    "- **[ ] (Character Set)**: Square brackets denote a character set, where one element inside must match. For example, `[abc]` would match any of the characters 'a,' 'b,' or 'c.' You can also specify ranges like `[0-9]` to match any digit.\n",
    "\n",
    "- **| (Pipe or Alternation)**: The pipe symbol represents an \"or\" element. For instance, `a|b` would match either 'a' or 'b.'\n",
    "\n",
    "- **{ } (Interval Quantifier)**: Curly braces are used to specify an interval or the number of times a pattern should repeat. For example, `a{2,4}` would match 'aa,' 'aaa,' or 'aaaa,' where the number of 'a's falls between 2 and 4.\n",
    "\n",
    "- **\\ (Backslash)**: The backslash is an escape character that identifies the next character as a literal character and not a special regular expression symbol. For example, `\\.` would match a period (.) rather than any character.\n",
    "\n",
    "- **. (Dot)**: In the default mode, the dot matches any character except a newline. For instance, `a.b` would match 'axb,' 'a#b,' or 'a$b,' where 'x,' '#,' and '$' can be any character except a newline.\n",
    "\n",
    "- **^ (Caret)**: The caret symbol matches the start of the string. In MULTILINE mode, it also matches immediately after each newline. For example, `^abc` would match 'abc' at the beginning of a line.\n",
    "\n",
    "- **$ (Dollar Sign)**: The dollar sign matches the end of the string or just before the newline at the end of the string. In MULTILINE mode, it also matches before a newline. For instance, `xyz$` would match 'xyz' at the end of a line.\n",
    "\n",
    "- **\\* (Asterisk)**: The asterisk causes the resulting regex to match 0 or more repetitions of the preceding pattern, as many repetitions as are possible. For example, `ab*` will match 'a' or 'ab' followed by any number of 'b's.\n",
    "\n",
    "- **+ (Plus)**: The plus sign causes the regex to match 1 or more repetitions of the preceding pattern. For instance, `ab+` will match 'a' followed by any non-zero number of 'b's but will not match just 'a.'\n",
    "\n",
    "- **? (Question Mark)**: The question mark causes the regex to match 0 or 1 repetitions of the preceding pattern. For example, `ab?` will match either 'a' or 'ab.'\n",
    "\n",
    "#### Additional Character Classes:\n",
    "\n",
    "- **\\d (Digit)**: Matches any decimal digit; this is equivalent to the character class [0-9].\n",
    "\n",
    "- **\\D (Non-Digit)**: Matches any non-digit character; this is equivalent to the character class [^0-9].\n",
    "\n",
    "- **\\s (Whitespace)**: Matches any whitespace character, including space, tab, newline, carriage return, form feed, and vertical tab. This is equivalent to the character class [ \\t\\n\\r\\f\\v].\n",
    "\n",
    "- **\\S (Non-Whitespace)**: Matches any non-whitespace character. This is equivalent to the character class [^ \\t\\n\\r\\f\\v].\n",
    "\n",
    "- **\\w (Word Character)**: Matches any alphanumeric character or underscore; this is equivalent to the character class [a-zA-Z0-9_].\n",
    "\n",
    "- **\\W (Non-Word Character)**: Matches any character that is not alphanumeric or underscore; this is equivalent to the character class [^a-zA-Z0-9_].\n",
    "\n",
    "Regular expressions can be a bit complex, but they are incredibly powerful for text processing tasks. For more comprehensive and complete documentation, refer to the [Python Regular Expression Documentation](http://docs.python.org/2/library/re.html#re-syntax).\n",
    "\n",
    "### Regular Expressions Examples\n",
    "\n",
    "Let's explore some basic regular expression patterns and their explanations:\n",
    "\n",
    "- **Example 1 - Matching Digits ( \\d )**:\n",
    "  - Pattern: `\\d+`\n",
    "  - Explanation: This pattern will match one or more digits (0-9) in a string. For instance, it will match '123' in 'abc123xyz'.\n",
    "\n",
    "- **Example 2 - Matching Email Addresses**:\n",
    "  - Pattern: `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}`\n",
    "  - Explanation: This pattern matches a basic email address. It looks for a sequence of characters, followed by '@,' then another sequence, a dot, and a domain with at least two letters. For example, it matches 'user@example.com.'\n",
    "\n",
    "- **Example 3 - Matching Dates (dd/mm/yyyy)**:\n",
    "  - Pattern: `\\d{2}/\\d{2}/\\d{4}`\n",
    "  - Explanation: This pattern matches a date in the format 'dd/mm/yyyy,' where 'dd' represents the day, 'mm' represents the month, and 'yyyy' represents the year. For example, it matches '25/12/2022.'\n",
    "\n",
    "- **Example 4 - Extracting URLs from Text**:\n",
    "  - Pattern: `https?://\\S+`\n",
    "  - Explanation: This pattern captures URLs that start with 'http://' or 'https://' and continue until the first whitespace character. For example, it matches 'https://www.example.com' within a text.\n",
    "\n",
    "- **Example 5 - Matching Words with Hyphens**:\n",
    "  - Pattern: `\\w+-\\w+`\n",
    "  - Explanation: This pattern matches words separated by hyphens. It looks for a sequence of alphanumeric characters, a hyphen, and another sequence of alphanumeric characters. For example, it matches 'cloud-based' in 'cloud-based solution.'\n",
    "\n",
    "Feel free to use these examples to practice regular expressions. You can adjust the patterns and test them against different strings to gain a better understanding of how regex works.\n",
    "\n",
    "# Exercise: Keep the good work and practice regex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# Exercise 1 - Matching Email Addresses\n",
    "# Write a regex pattern to match email addresses and find all email addresses in the given text.\n",
    "text1 = \"Contact us at support@example.com or info@company.net for assistance.\"\n",
    "\n",
    "# Exercise 2 - Extracting Dates\n",
    "# Write a regex pattern to extract dates in the format 'dd/mm/yyyy' from the given text.\n",
    "text2 = \"Meeting scheduled for 25/12/2022. Please RSVP by 31/12/2022.\"\n",
    "\n",
    "# Exercise 3 - Finding URLs\n",
    "# Write a regex pattern to find URLs that start with 'http://' or 'https://'.\n",
    "text3 = \"Visit our website at http://www.example.com or explore more at https://www.sample-site.org.\"\n",
    "\n",
    "# Exercise 4 - Extracting Phone Numbers\n",
    "# Write a regex pattern to extract phone numbers in the format '(xxx) xxx-xxxx' from the given text.\n",
    "text4 = \"Contact us at (123) 456-7890 or reach us at (987) 654-3210 for inquiries.\"\n",
    "\n",
    "# Exercise 5 - Matching Words with Hyphens\n",
    "# Write a regex pattern to match words separated by hyphens.\n",
    "text5 = \"This is a text with cloud-based solutions and state-of-the-art technology.\"\n",
    "\n",
    "# Exercise 6 - Custom Pattern\n",
    "# Write your custom regex pattern and test it with a text of your choice.\n",
    "\n",
    "# Exercise 7 - Matching Dates (mm/dd/yyyy)\n",
    "# Write a regex pattern to match dates in the format 'mm/dd/yyyy' from the given text.\n",
    "text7 = \"Meeting scheduled for 12/25/2022. Please RSVP by 12/31/2022.\"\n",
    "\n",
    "# Exercise 8 - Extracting Hashtags\n",
    "# Write a regex pattern to extract hashtags (words starting with #) from the given text.\n",
    "text8 = \"Join the conversation with #topic1, #discussion, and #feedback.\"\n",
    "\n",
    "# Exercise 9 - Extracting Mentioned Users\n",
    "# Write a regex pattern to extract mentioned usernames (words starting with @) from the given text.\n",
    "text9 = \"Contact @user123 for assistance or follow @officialpage for updates.\"\n",
    "\n",
    "# Exercise 10 - Matching Phone Numbers (with optional country code)\n",
    "# Write a regex pattern to match phone numbers in the format '(+xx) xxx-xxxx' or '(xxx) xxx-xxxx' from the given text.\n",
    "text10 = \"Contact us at (+1) 123-456-7890 or (987) 654-3210 for inquiries.\"\n",
    "\n",
    "# Define regex patterns for each exercise\n",
    "pattern1 = r''\n",
    "pattern2 = r''\n",
    "pattern3 = r''\n",
    "pattern4 = r''\n",
    "pattern5 = r''\n",
    "pattern7 = r''\n",
    "pattern8 = r''\n",
    "pattern9 = r''\n",
    "pattern10 = r''\n",
    "\n",
    "# Find and print matches for each exercise\n",
    "print(\"Exercise 1 - Matching Email Addresses:\")\n",
    "print(re.findall(pattern1, text1))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 2 - Extracting Dates:\")\n",
    "print(re.findall(pattern2, text2))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 3 - Finding URLs:\")\n",
    "print(re.findall(pattern3, text3))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 4 - Extracting Phone Numbers:\")\n",
    "print(re.findall(pattern4, text4))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 5 - Matching Words with Hyphens:\")\n",
    "print(re.findall(pattern5, text5))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 7 - Matching Dates (mm/dd/yyyy):\")\n",
    "print(re.findall(pattern7, text7))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 8 - Extracting Hashtags:\")\n",
    "print(re.findall(pattern8, text8))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 9 - Extracting Mentioned Users:\")\n",
    "print(re.findall(pattern9, text9))\n",
    "print()\n",
    "\n",
    "print(\"Exercise 10 - Matching Phone Numbers (with optional country code):\")\n",
    "print(re.findall(pattern10, text10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capturing Groups in Regular Expressions\n",
    "\n",
    "Capturing groups are a powerful feature in regular expressions that allow you to extract specific parts of a matched text. In Python, you can work with capturing groups using the `SRE_Match` objects and methods like `.groups()` and `.group()`.\n",
    "\n",
    "#### What Are Capturing Groups?\n",
    "\n",
    "A capturing group is a portion of a regex pattern enclosed in parentheses `( )`. It serves two main purposes:\n",
    "\n",
    "1. **Grouping:** You can use parentheses to group parts of a pattern together. This is helpful for applying quantifiers like `*`, `+`, or `?` to multiple characters or subpatterns. For example, `(ab)+` will match one or more occurrences of 'ab' as a group.\n",
    "\n",
    "2. **Extraction:** Capturing groups allow you to extract specific portions of the matched text. Each set of parentheses creates a separate capturing group, and you can access the matched content of these groups individually.\n",
    "\n",
    "#### Using Capturing Groups in Python\n",
    "\n",
    "In Python, when you use regular expressions, the resulting match object (`SRE_Match`) provides methods for working with capturing groups:\n",
    "\n",
    "- **`.groups()`**: This method returns a tuple containing all the captured groups. The 0th element of this tuple is the entire match of the whole regex.\n",
    "\n",
    "- **`.group(n)`**: To access a specific capturing group, you pass its index `n` to the `.group()` method. The index is based on the order of opening parentheses in the regex pattern, starting from 1. Index 0 refers to the entire match.\n",
    "\n",
    "#### Example:\n",
    "\n",
    "Let's illustrate the concept with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# Suppose we want to extract dates in the format \"dd/mm/yyyy\" from a text.\n",
    "text = \"Meeting scheduled for 25/12/2022 and 31/12/2022.\"\n",
    "\n",
    "# Define the regex pattern with capturing groups for day, month, and year.\n",
    "pattern = r'(\\d{2})/(\\d{2})/(\\d{4})'\n",
    "\n",
    "# Search for matches using the pattern.\n",
    "matches = re.finditer(pattern, text)\n",
    "\n",
    "# Iterate through the matches and access capturing groups.\n",
    "for match in matches:\n",
    "    # The entire match (0th group) is accessible as match.group(0).\n",
    "    print(f\"Full Match: {match.group(0)}\")\n",
    "    \n",
    "    # Access individual capturing groups using match.group(n).\n",
    "    day = match.group(1)\n",
    "    month = match.group(2)\n",
    "    year = match.group(3)\n",
    "    \n",
    "    print(f\"Day: {day}, Month: {month}, Year: {year}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we use capturing groups to extract day, month, and year components of the date. Students can see how to access these components using the `.group(n)` method and understand the utility of capturing groups in extracting specific information from text matched by a regex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of Useful Functions for Regular Expressions\n",
    "\n",
    "When working with regular expressions in Python, you can utilize several built-in functions provided by the `re` module. Here's an overview of these functions and what they do:\n",
    "\n",
    "- **`re.match(pattern, string)`**: This function checks if the regex pattern matches at the beginning of the input string. It returns a match object if a match is found at the start of the string or `None` otherwise.\n",
    "\n",
    "- **`re.search(pattern, string)`**: This function scans through a string, looking for any location where the regex pattern matches. It returns a match object for the first occurrence found or `None` if no match is found.\n",
    "\n",
    "- **`re.findall(pattern, string)`**: This function finds all non-overlapping substrings where the regex pattern matches in the input string and returns them as a list.\n",
    "\n",
    "- **`re.finditer(pattern, string)`**: This function finds all non-overlapping substrings where the regex pattern matches in the input string and returns them as an iterator.\n",
    "\n",
    "These functions are essential for various text processing tasks, enabling you to search for and manipulate patterns within strings efficiently.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Use case examples using regular expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_sentences(pattern, sentences):\n",
    "    \"\"\"\n",
    "    Check sentences against the provided regular expression pattern.\n",
    "\n",
    "    Args:\n",
    "        pattern (str): The regular expression pattern to match against.\n",
    "        sentences (list of tuple): A list of tuples where each tuple contains a sentence and an expected result (True or False).\n",
    "\n",
    "    Returns:\n",
    "        None\n",
    "\n",
    "    Prints:\n",
    "        Feedback for each sentence based on whether it matches the pattern or not.\n",
    "    \"\"\"\n",
    "\n",
    "    for sentence, expected_result in sentences:\n",
    "        # Check if the pattern matches the entire string and compare it to the expected result.\n",
    "        is_match = bool(re.match(pattern, sentence))\n",
    "\n",
    "        # Determine if the result matches the expected outcome.\n",
    "        is_valid = is_match == expected_result\n",
    "\n",
    "        # Print feedback based on the match and validity.\n",
    "        if is_valid:\n",
    "            result_message = 'Pass'\n",
    "        else:\n",
    "            result_message = 'Not Pass'\n",
    "\n",
    "        validity_message = '(Valid)' if expected_result else '(Not Valid)'\n",
    "        print(f'{result_message} --> {sentence} {validity_message}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation of the `check_sentences` Function**\n",
    "\n",
    "The `check_sentences` function is designed to evaluate a list of sentences against a provided regular expression pattern and provide feedback on whether each sentence matches the pattern as expected.\n",
    "\n",
    "**Function Parameters**\n",
    "\n",
    "- `pattern`: This parameter represents the regular expression pattern to which each sentence will be compared.\n",
    "\n",
    "- `sentences`: This parameter is a list of tuples where each tuple contains a sentence and an expected result (True or False). The expected result indicates whether the sentence is expected to match the pattern or not.\n",
    "\n",
    "**Function Purpose**\n",
    "\n",
    "The primary purpose of this function is to check each sentence in the `sentences` list against the provided regular expression pattern and provide feedback based on whether the match is as expected. It assists in validating whether sentences conform to a particular pattern.\n",
    "\n",
    "**Function Execution**\n",
    "\n",
    "1. The function iterates through each tuple in the `sentences` list, extracting the sentence and its associated expected result.\n",
    "\n",
    "2. For each sentence, it uses the `re.match()` function to determine if the provided regular expression pattern matches the entire sentence. The result of this match is stored in a variable.\n",
    "\n",
    "3. The function then evaluates whether the match is valid by comparing it to the expected result. If the match and expected result match, the sentence is considered valid; otherwise, it is not valid.\n",
    "\n",
    "4. Based on the validity of the match, the function assigns a result message such as \"Pass\" or \"Not Pass\" for feedback.\n",
    "\n",
    "5. The function also determines whether the sentence is \"Valid\" or \"Not Valid\" based on the expected result and prepares a validity message.\n",
    "\n",
    "6. Finally, the function prints feedback for each sentence, indicating whether it passed or not, along with the sentence itself and whether it is considered valid or not valid.\n",
    "\n",
    "**Function Output**\n",
    "\n",
    "The function prints feedback messages for each sentence, providing insights into whether each sentence conforms to the specified regular expression pattern. This feedback assists in validating and verifying text data against a defined pattern.\n",
    "\n",
    "The `check_sentences` function is a valuable tool for quality control and validation tasks involving text data, enabling the assessment of data integrity against predefined patterns or rules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Identify files via file extensions\n",
    "<p>A regular expression to check for file extensions.  </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# Define a regex pattern to match file names with specific extensions (gif, jpeg, jpg, TIF).\n",
    "pattern = r'[\\w]+\\.(gif|jpeg|jpg|TIF)$'\n",
    "\n",
    "# Define a list of sentences to be checked against the pattern, along with their expected results.\n",
    "sentences = [('test.gif', True), \n",
    "            ('image.jpeg', True),\n",
    "            ('image.jpg', True),\n",
    "            ('image.TIF', True),\n",
    "            ('test', False),\n",
    "            ('test.pdf', False),\n",
    "            ('test.gif.gif', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Checking for numbers\n",
    "#### 2. Positive integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regex pattern to match strings consisting of one or more digits.\n",
    "pattern = r'\\d*$'\n",
    "\n",
    "# Define a list of sentences to be checked against the pattern, along with their expected results.\n",
    "sentences = [('123', True), \n",
    "            ('1', True),\n",
    "            ('abc', False),\n",
    "            ('1.1', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### 3. Negative integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regular expression pattern to match strings starting with a hyphen followed by one or more digits at the end.\n",
    "pattern = r'-\\d+$'\n",
    "\n",
    "# Create a list of sentences, each with an associated expected result (True or False).\n",
    "sentences = [('-123', True),\n",
    "            ('-1', True),\n",
    "            ('123', False),\n",
    "            ('-abc', False),\n",
    "            ('-1.1', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### 4. All integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regular expression pattern to match strings that may start with an optional hyphen followed by one or more digits at the end.\n",
    "pattern = r'-?\\d+$'\n",
    "\n",
    "# Create a list of sentences, each with an associated expected result (True or False).\n",
    "sentences = [('-123', True),\n",
    "            ('-1', True),\n",
    "            ('123', True),\n",
    "            ('123.0', False),\n",
    "            ('-abc', False),\n",
    "            ('-1.1', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### 5. Positive numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regular expression pattern to match strings representing decimal numbers.\n",
    "pattern = r'\\d*\\.?\\d+$'\n",
    "\n",
    "# Create a list of sentences, each with an associated expected result (True or False).\n",
    "sentences = [('1', True),\n",
    "            ('123', True),\n",
    "            ('1.234', True),\n",
    "            ('0.2', True),\n",
    "            ('.2', True),\n",
    "            ('-123.0', False),\n",
    "            ('-abc', False),\n",
    "            ('-123.1', False)]\n",
    "\n",
    "# Print the pattern being used for matching.\n",
    "print(\"PATTERN:\", pattern)\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### 6. Negative numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regular expression pattern to match strings representing negative decimal numbers.\n",
    "pattern = r'-\\d*\\.?\\d+$'\n",
    "\n",
    "# Create a list of sentences, each with an associated expected result (True or False).\n",
    "sentences = [('-1', True),\n",
    "            ('-123', True),\n",
    "            ('-1.234', True),\n",
    "            ('123', False),\n",
    "            ('-abc', False),\n",
    "            ('123.1', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### 7. All numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a regular expression pattern to match strings representing decimal numbers, including optional negative sign.\n",
    "pattern = r'-?\\d*\\.?\\d+$'\n",
    "\n",
    "# Create a list of sentences, each with an associated expected result (True or False).\n",
    "sentences = [('1', True),\n",
    "            ('123', True),\n",
    "            ('1.234', True),\n",
    "            ('-234', True),\n",
    "            ('-1.234', True),\n",
    "            ('a', False),\n",
    "            ('-abc', False),\n",
    "            ('a1', False)]\n",
    "\n",
    "# Call the check_sentences function with the pattern and sentences to perform the checks.\n",
    "check_sentences(pattern, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 8. Username validation\n",
    "<p>Checking for a valid user name that has a certain minimum and maximum length.</p>\n",
    "<p>Allowed characters:</p>\n",
    "<ul>\n",
    "<li>letters (upper- and lower-case)</li>\n",
    "<li>numbers</li>\n",
    "<li>dashes</li>\n",
    "<li>underscores</li>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_len = 5 # minimum length for a valid username\n",
    "max_len = 15 # maximum length for a valid username\n",
    "\n",
    "pattern = r'[\\w_-]{5,15}$'\n",
    "\n",
    "sentences = [('user123',True), ('123_user', True),('Username',True),\n",
    "            ('user',False),('username1234_is-way-too-long',False),('user$34354',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 9. Checking for valid email addresses\n",
    "A regular expression that captures most email addresses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r'(^(?i)(\\w+\\.|\\w+-)*\\w+@(\\w+\\.|\\w+-)*\\w+\\.[a-z]{2,3}$)'\n",
    "\n",
    "sentences = [('l-l.l@mail.Aom.PP',True), ('ds@mail.com', True),\n",
    "            ('testmail.com',False),('test@mail.com.',False),('@testmail.com',False),('test@mailcom',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use case challenges using regular expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1. Validating dates and time\n",
    "Validates dates in mm/dd/yyyy format. note: Some dates are not verified such as 2080 to be invalid. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r''\n",
    "\n",
    "\n",
    "\n",
    "sentences = [('01/08/2014',True), ('12/30/2014', True),\n",
    "            ('22/08/2014',False),('-123',False),('1/8/2014',False),('1/08/2014',False),('01/8/2014',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 2. 12-Hour format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r''\n",
    "\n",
    "\n",
    "\n",
    "sentences = [('2:00pm',True), ('7:30 AM', True), ('12:05 am', True),\n",
    "            ('22:00pm',False),('14:00',False),('3:12',False),('03:12pm',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 3. 24-Hour format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r''\n",
    "\n",
    "\n",
    "sentences = [('14:00',True), ('00:30', True), \n",
    "            ('22:00pm',False),('4:00',False),('03:12pm',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 4. Checking for HTML/XML, etc. tags (a very simple approach)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r''\n",
    "\n",
    "sentences = [('<a>',True), ('<a href=\"somethinG\">', True),  ('</a>', True),  ('<img src>', True), \n",
    "            ('a>',False),('<a',False),('< a >',False)]\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 5. ID/Passport/NIF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = r''\n",
    "\n",
    "\n",
    "sentences = [('12345678D',True), ('X1234567F', True), \n",
    "             ('123456F',False),('X12367F',False),('123Ff456F',False)]\n",
    "\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6. Website Names\n",
    "Define the pattern to detect if a string corresponds to a website name. The pattern follows these rules:\n",
    "* It can start with either three \"w\"s or directly with the domain name.\n",
    "* It is followed by the domain name, which can contain any letters and numbers.\n",
    "* It can have a maximum of 2 subdomains (composed of letters and numbers).\n",
    "* It ends with a period followed by 2 or 3 letters.\n",
    "\n",
    "You should detect the following cases:\n",
    "* Positives:\n",
    "    * www.ds.com\n",
    "    * www.data.science.com\n",
    "    * datascience.com\n",
    "    * wab.a.com\n",
    "* Negatives:\n",
    "    * ww.4com\n",
    "    * www.ww.a\n",
    "    * www.d.s.c.d.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = ''\n",
    "\n",
    "\n",
    "sentences = [('www.ds.com',True), ('www.data.science.com', True),  ('datascience.com', True),  ('data.sc.com', True), \n",
    "            ('ww.4com',False),('www.ww.a',False),('www.d.s.c.d.com',False)]\n",
    "\n",
    "\n",
    "check_sentences(pattern,sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define regex patterns for each exercise\n",
    "pattern1 = r'\\w+@\\w+\\.\\w+'\n",
    "pattern2 = r'\\d{2}/\\d{2}/\\d{4}'\n",
    "pattern3 = r'https?://\\S+'\n",
    "pattern4 = r'\\(\\d{3}\\) \\d{3}-\\d{4}'\n",
    "pattern5 = r'\\w+-\\w+'\n",
    "pattern7 = r'\\d{2}/\\d{2}/\\d{4}'\n",
    "pattern8 = r'#\\w+'\n",
    "pattern9 = r'@\\w+'\n",
    "pattern10 = r'\\(?\\+\\d{1,2}\\)? \\d{3}-\\d{4}'"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}