## Masquage des informations sensibles avec les expressions régulières

Dans de nombreux scénarios réels, il est nécessaire de protéger les informations sensibles présentes dans un texte, comme les numéros de carte de crédit. À l'aide des **expressions régulières**, il est possible de localiser ces numéros et de les masquer efficacement. L'objectif est d'écrire une fonction qui remplace tous les chiffres sauf les quatre derniers de chaque numéro de carte de crédit dans une chaîne donnée par des astérisques (`*`). Le résultat masqué doit :

- Préserver la longueur et le format d'origine du numéro ;
- Afficher uniquement les quatre derniers chiffres pour l'identification.

**Exemple :**

- Entrée : `"My card is 1234-5678-9012-3456"` ;
- Sortie : `"My card is ****-****-****-3456"`.

Utiliser le module `re` de Python pour implémenter cette solution.


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_mask_simple_hyphenated(self):
        import user_code
        importlib.reload(user_code)
        text = "My card is 1234-5678-9012-3456"
        expected = "My card is ****-****-****-3456"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Correctly masks hyphen-separated credit card number.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_mask_simple_spaced(self):
        import user_code
        importlib.reload(user_code)
        text = "Card: 1234 5678 9012 3456"
        expected = "Card: **** **** **** 3456"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Correctly masks space-separated credit card number.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_mask_nospaces(self):
        import user_code
        importlib.reload(user_code)
        text = "CC: 1234567890123456 and 6543210987654321"
        expected = "CC: ************3456 and ************4321"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Correctly masks continuous 16-digit credit card numbers.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_mask_multiple_formats(self):
        import user_code
        importlib.reload(user_code)
        text = "1: 1111-2222-3333-4444, 2: 5555 6666 7777 8888, 3: 9999888877776666"
        expected = "1: ****-****-****-4444, 2: **** **** **** 8888, 3: ************6666"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Correctly masks multiple credit card numbers in various formats.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_partial_digits_not_masked(self):
        import user_code
        importlib.reload(user_code)
        text = "Not a card: 1234-5678-9012"
        expected = "Not a card: 1234-5678-9012"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Does not mask numbers that are not 16 digits.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_mixed_separators(self):
        import user_code
        importlib.reload(user_code)
        text = "Card: 1234-5678 9012-3456"
        expected = "Card: ****-**** ****-3456"
        result = user_code.mask_credit_card_numbers(text)
        _dynamic_test(
            self,
            result == expected,
            "Correctly masks credit card numbers with mixed separators.",
            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.

Challenge : Masquer les informations sensibles

Masquage des informations sensibles avec les expressions régulières

Challenge : Masquer les informations sensibles

Masquage des informations sensibles avec les expressions régulières

Solution