## Instructions:

To further develop your skills with advanced regular expressions, your task is to create a function that extracts all hashtags from a social media post.

A **hashtag** is any word that starts with the `#` character, followed by one or more alphanumeric characters or underscores, and is not immediately preceded by another word character.

Your function should:

- Handle hashtags at the beginning or end of the text;
- Correctly extract hashtags surrounded by punctuation or whitespace;
- Return all hashtags exactly as they appear in the text, including the `#` symbol.

**Example:**

Given the input:

```python
"Excited for the #Python3_12 release! #coding #AI #100DaysOfCode"
```

you should return:

```python
['#Python3_12', '#coding', '#AI', '#100DaysOfCode']
```

Use regular expressions to solve this challenge and pay special attention to edge cases.


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_hashtags(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("Excited for the #Python3_12 release! #coding #AI #100DaysOfCode")
        expected = ['#Python3_12', '#coding', '#AI', '#100DaysOfCode']
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correct hashtags extracted from example text",
            f"Expected {expected}, got {result}",
        )

    def test_hashtags_with_punctuation(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("Check this! #fun, #challenge.#end #_underscore #123 ")
        expected = ['#fun', '#challenge', '#end', '#_underscore', '#123']
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts hashtags with punctuation and underscores",
            f"Expected {expected}, got {result}",
        )

    def test_hashtags_at_edges(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("#start Middle #middle End#not #end")
        expected = ['#start', '#middle', '#end']
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts hashtags at the start and end of text",
            f"Expected {expected}, got {result}",
        )

    def test_no_hashtags(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("There are no hashtags here.")
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list when no hashtags are present",
            f"Expected {expected}, got {result}",
        )

    def test_hashtag_not_preceded_by_wordchar(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("abc#wrong #right")
        expected = ['#right']
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Does not match hashtags immediately following a word character",
            f"Expected {expected}, got {result}",
        )

    def test_multiple_adjacent_hashtags(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.extract_hashtags("##double #single###triple")
        expected = ['#double', '#single', '#triple']
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Extracts hashtags from multiple adjacent hashes",
            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 Hashtags from Social Media Text

Instructions:

Solución

Awesome!

Challenge: Extract Hashtags from Social Media Text

Instructions:

Solución