You will write a function that extracts all words starting with the uppercase letter **'A'** from a given string. This exercise will help you practice using basic regular expression patterns and Python's `re` module. Only words beginning with a capital 'A' should be matched—**the search must be case-sensitive**.

**Key Points:**

- Use Python's `re` module;
- Match only words that start with uppercase 'A';
- Preserve the original form of each matched word from the text.


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_extraction(self):
        import user_code
        importlib.reload(user_code)
        text = "Alice and Andrew went to the Aquarium."
        result = user_code.find_words_starting_with_a(text)
        expected = ["Alice", "Andrew", "Aquarium"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            f"Correctly finds words starting with 'A': {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_no_matches(self):
        import user_code
        importlib.reload(user_code)
        text = "bob and charlie went home."
        result = user_code.find_words_starting_with_a(text)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list when no words start with 'A'",
            f"Expected empty list, got {result}",
        )

    def test_case_sensitive(self):
        import user_code
        importlib.reload(user_code)
        text = "apple Apple ALice aaron Aaron"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Apple", "ALice", "Aaron"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function is case-sensitive and includes only words starting with uppercase 'A'",
            f"Expected {expected}, got {result}",
        )

    def test_punctuation(self):
        import user_code
        importlib.reload(user_code)
        text = "Amy, Ann! Alan? Aardvark."
        result = user_code.find_words_starting_with_a(text)
        expected = ["Amy", "Ann", "Alan", "Aardvark"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts words with punctuation after them",
            f"Expected {expected}, got {result}",
        )

    def test_single_word(self):
        import user_code
        importlib.reload(user_code)
        text = "Aardvark"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Aardvark"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly returns single word starting with 'A'",
            f"Expected {expected}, got {result}",
        )

    def test_word_boundaries(self):
        import user_code
        importlib.reload(user_code)
        text = "AnA A1 A_ A!"
        result = user_code.find_words_starting_with_a(text)
        expected = ["AnA", "A1", "A_", "A"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly matches all words starting with 'A' including numbers and underscores",
            f"Expected {expected}, got {result}",
        )

    def test_preserves_original(self):
        import user_code
        importlib.reload(user_code)
        text = "Aardvark Annabelle"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Aardvark", "Annabelle"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns words exactly as they appear in the text",
            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: Find Words Starting with a Specific Letter

Ratkaisu

Awesome!

Challenge: Find Words Starting with a Specific Letter

Ratkaisu