Use your knowledge of **character classes** and **quantifiers** to extract all email addresses from a block of text. Email addresses follow specific patterns, making them ideal candidates for **regular expression** matching. Your goal is to write a function that scans a given string and returns every email address it finds.

- Identify the pattern of a typical email address (for example, `username@example.com`);
- Use Python's `re` module to construct a regular expression that matches email addresses;
- Write a function that returns a list of all email addresses found in the input string.

**Quantifiers** in regular expressions let you specify how many times a character, character class, or group must occur for a match. This is essential for patterns like email addresses, where parts of the address can repeat or vary in length. For example, in the pattern `[a-zA-Z0-9._%+-]+`, the `+` quantifier means "match one or more of the preceding characters." Common quantifiers include `*` (zero or more), `+` (one or more), and `{n,m}` (between *n* and *m* times). Using quantifiers helps you build flexible patterns that match a wide range of text formats.

Note


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_basic_emails(self):
        import user_code
        importlib.reload(user_code)
        text = "Contact us at support@example.com or sales@company.org for details."
        result = user_code.extract_emails(text)
        expected = ["support@example.com", "sales@company.org"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts multiple emails in order",
            f"Expected {expected}, got {result}",
        )

    def test_no_emails(self):
        import user_code
        importlib.reload(user_code)
        text = "No email addresses here!"
        result = user_code.extract_emails(text)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns an empty list when no emails are present",
            f"Expected empty list, got {result}",
        )

    def test_varied_emails(self):
        import user_code
        importlib.reload(user_code)
        text = "Emails: first.last@domain.co.uk, foo_bar-123@sub.domain.com, x@y.io."
        result = user_code.extract_emails(text)
        expected = ["first.last@domain.co.uk", "foo_bar-123@sub.domain.com", "x@y.io"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts emails with subdomains and country TLDs",
            f"Expected {expected}, got {result}",
        )

    def test_emails_with_extra_characters(self):
        import user_code
        importlib.reload(user_code)
        text = "Contact: <admin@website.com>, (info@web.org)!"
        result = user_code.extract_emails(text)
        expected = ["admin@website.com", "info@web.org"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Ignores punctuation around emails",
            f"Expected {expected}, got {result}",
        )

    def test_case_sensitivity(self):
        import user_code
        importlib.reload(user_code)
        text = "Write to John.DOE@Example.Com for info."
        result = user_code.extract_emails(text)
        expected = ["John.DOE@Example.Com"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Preserves original case of email addresses",
            f"Expected {expected}, got {result}",
        )

    def test_repeated_emails(self):
        import user_code
        importlib.reload(user_code)
        text = "Repeat: a@b.com a@b.com"
        result = user_code.extract_emails(text)
        expected = ["a@b.com", "a@b.com"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns all occurrences, including duplicates, in order",
            f"Expected {expected}, got {result}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

A comprehensive course on Python regular expressions, designed for learners with basic Python knowledge. This course covers regex syntax, pattern matching, advanced features, and practical applications through theory and hands-on tasks.

Learn the fundamentals of regular expressions in Python, including basic syntax, pattern matching, and essential regex functions.

Delve deeper into regex with grouping, quantifiers, anchors, and substitution techniques.

Master advanced regex features such as lookahead/lookbehind, non-greedy matching, and apply regex to real-world text processing problems.

Challenge: Extract Email Addresses

Рішення