
To strengthen your skills with grouping and quantifiers in regular expressions, you will now write a function to extract dates from text. The goal is to identify dates in the formats **"YYYY-MM-DD"** (such as `2024-06-15`) and **"DD/MM/YYYY"** (such as `15/06/2024`). Your function should scan a string and return all matching dates in a list. This exercise will help you practice using **groups**, **quantifiers**, and **alternation** to match multiple date formats reliably.


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_example_output(self):
        import user_code

        importlib.reload(user_code)
        text = "The events are on 2024-06-15 and 15/06/2024."
        result = user_code.extract_dates(text)
        expected = ["2024-06-15", "15/06/2024"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function returns correct list for mixed formats.",
            f"Expected {expected}, got {result}",
        )

    def test_multiple_dates(self):
        import user_code
        importlib.reload(user_code)
        text = "Dates: 2022-01-01, 31/12/2023, and 2020-05-10."
        result = user_code.extract_dates(text)
        expected = ["2022-01-01", "31/12/2023", "2020-05-10"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function finds multiple dates in both formats.",
            f"Expected {expected}, got {result}",
        )

    def test_no_dates(self):
        import user_code
        importlib.reload(user_code)
        text = "There are no dates here."
        result = user_code.extract_dates(text)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function returns empty list when no dates present.",
            f"Expected {expected}, got {result}",
        )

    # def test_edge_cases(self):
    #     import user_code
    #     importlib.reload(user_code)
    #     text = "Start:2021-12-31End:01/01/2022More:2022-02-02!"
    #     result = user_code.extract_dates(text)
    #     expected = ["2021-12-31", "01/01/2022", "2022-02-02"]
    #     _dynamic_test(
    #         self,
    #         isinstance(result, list) and result == expected,
    #         "Function finds dates at string edges and with punctuation.",
    #         f"Expected {expected}, got {result}",
    #    )

    def test_invalid_dates(self):
        import user_code
        importlib.reload(user_code)
        text = "These are not dates: 2024-6-15, 5/6/2024, 20240615, 15-06-2024."
        result = user_code.extract_dates(text)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function does not match invalid date formats.",
            f"Expected {expected}, got {result}",
        )

    def test_overlapping_dates(self):
        import user_code
        importlib.reload(user_code)
        text = "2023-12-24/2023-12-25 and 24/12/2023/25/12/2023"
        result = user_code.extract_dates(text)
        expected = ["2023-12-24", "2023-12-25", "24/12/2023", "25/12/2023"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function finds adjacent and overlapping dates.",
            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 Dates in Various Formats

解答