## Instructions :

Pour approfondir vos compétences avec les expressions régulières avancées, votre tâche consiste à créer une fonction qui extrait tous les hashtags d’une publication sur les réseaux sociaux.

Un **hashtag** est tout mot qui commence par le caractère `#`, suivi d’un ou plusieurs caractères alphanumériques ou de soulignement, et qui n’est pas immédiatement précédé par un autre caractère de mot.

Votre fonction doit :

- Gérer les hashtags au début ou à la fin du texte ;
- Extraire correctement les hashtags entourés de ponctuation ou d’espaces ;
- Retourner tous les hashtags exactement tels qu’ils apparaissent dans le texte, y compris le symbole `#`.

**Exemple :**

Pour l’entrée :

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

vous devez retourner :

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

Utilisez les expressions régulières pour résoudre ce défi et portez une attention particulière aux cas limites.


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

Un cours complet sur les expressions régulières en Python, conçu pour les apprenants ayant des connaissances de base en Python. Ce cours couvre la syntaxe des regex, la correspondance de motifs, les fonctionnalités avancées et les applications pratiques à travers la théorie et des exercices pratiques.

Apprenez les bases des expressions régulières en Python, y compris la syntaxe de base, la correspondance de motifs et les fonctions regex essentielles.

Approfondissement des expressions régulières avec les groupements, les quantificateurs, les ancres et les techniques de substitution.

Maîtrise des fonctionnalités avancées des expressions régulières telles que le lookahead/lookbehind, la correspondance non-gourmande, et application des expressions régulières à des problèmes réels de traitement de texte.

Défi : Extraire les hashtags à partir du texte des réseaux sociaux

Instructions :

Défi : Extraire les hashtags à partir du texte des réseaux sociaux

Instructions :

Solution