
To practice applying advanced regular expression techniques, you will create a password validator that checks if a password is **strong**. 

Write a function called `is_strong_password(password)` that returns `True` if the password meets all these requirements, and `False` otherwise. Use regular expressions to perform the necessary checks.


import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_valid_strong_password(self):
        import user_code
        importlib.reload(user_code)
        password = "Abcdef1$"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is True,
            "Correctly returns True for valid strong password.",
            f"Expected True for password '{password}', got {result}.",
        )

    def test_too_short(self):
        import user_code
        importlib.reload(user_code)
        password = "Ab1$e"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is False,
            "Correctly returns False for password shorter than 8 characters.",
            f"Expected False for short password '{password}', got {result}.",
        )

    def test_missing_uppercase(self):
        import user_code
        importlib.reload(user_code)
        password = "abcdef1$"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is False,
            "Correctly returns False for password missing uppercase letter.",
            f"Expected False for password missing uppercase '{password}', got {result}.",
        )

    def test_missing_lowercase(self):
        import user_code
        importlib.reload(user_code)
        password = "ABCDEFG1$"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is False,
            "Correctly returns False for password missing lowercase letter.",
            f"Expected False for password missing lowercase '{password}', got {result}.",
        )

    def test_missing_digit(self):
        import user_code
        importlib.reload(user_code)
        password = "Abcdefg$"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is False,
            "Correctly returns False for password missing digit.",
            f"Expected False for password missing digit '{password}', got {result}.",
        )

    def test_missing_special_character(self):
        import user_code
        importlib.reload(user_code)
        password = "Abcdefg1"
        result = user_code.is_strong_password(password)
        _dynamic_test(
            self,
            result is False,
            "Correctly returns False for password missing special character.",
            f"Expected False for password missing special character '{password}', got {result}.",
        )

    def test_special_characters_variety(self):
        import user_code
        importlib.reload(user_code)
        passwords = ["Abcdef1@", "Abcdef1#", "Abcdef1!", "Abcdef1_"]
        for pw in passwords:
            result = user_code.is_strong_password(pw)
            _dynamic_test(
                self,
                result is True,
                f"Correctly returns True for strong password '{pw}'.",
                f"Expected True for strong password '{pw}', 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: Validate Strong Passwords

解答