import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.src = f.read()

        cls.exp_name_clean = "Ada Lovelace"
        cls.exp_has_quick = True
        cls.exp_inside_parens = "quick"
        cls.exp_o_count = 4
        cls.exp_domain = "example.com"
        cls.exp_report = f"{cls.exp_name_clean} | {cls.exp_domain} | {cls.exp_o_count}"

    def test_name_clean(self):
        ok = hasattr(self.m, "name_clean") and self.m.name_clean == self.exp_name_clean
        used_strip = re.search(r"full_name\s*\.\s*strip\s*\(\s*\)", self.src)
        _dynamic_test(self, ok and used_strip,
                      "name_clean computed correctly",
                      "name_clean computed incorrectly")

    def test_has_quick_and_o_count(self):
        ok = hasattr(self.m, "has_quick") and hasattr(self.m, "o_count")
        vals = ok and self.m.has_quick == self.exp_has_quick and self.m.o_count == self.exp_o_count
        pat_quick = re.search(r'''["']quick["']\s+in\s+sentence\s*\.\s*lower''', self.src)
        pat_count = re.search(r'''sentence\s*\.\s*lower\s*\(\s*\)\s*\.\s*count\s*\(\s*["']o["']\s*\)''', self.src)
        _dynamic_test(self, vals and pat_quick and pat_count,
                      "has_quick and o_count computed correctly",
                      "has_quick or o_count computed incorrectly")

    def test_inside_parens(self):
        ok = hasattr(self.m, "inside_parens") and self.m.inside_parens == self.exp_inside_parens
        slice_pat = re.search(r"sentence\s*\[\s*start\s*\+\s*1\s*:\s*end\s*\]", self.src)
        _dynamic_test(self, ok and slice_pat,
                      "inside_parens computed correctly",
                      "inside_parens computed incorrectly")

    def test_domain(self):
        ok = hasattr(self.m, "domain") and self.m.domain == self.exp_domain
        pat_strip = re.search(r"email\s*\.\s*strip\s*\(\s*\)\s*\.\s*lower\s*\(\s*\)", self.src)
        pat_find = re.search(r'''find\s*\(\s*["']@["']\s*\)''', self.src)
        _dynamic_test(self, ok and pat_strip and pat_find,
                      "domain computed correctly",
                      "domain computed incorrectly")

    def test_report(self):
        ok = hasattr(self.m, "report") and self.m.report == self.exp_report
        pat_f = re.search(r'''f["']\{name_clean\}.*\{SEP\}.*\{domain\}.*\{SEP\}.*\{o_count\}["']''', self.src)
        _dynamic_test(self, ok and pat_f,
                      "report computed correctly",
                      "report computed incorrectly")

if __name__ == "__main__":
    unittest.main()

test_code.py

Acquérez une compréhension solide des principaux types de données de Python et apprenez à les manipuler efficacement. Explorez les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développez votre confiance dans l'exécution des opérations de base et acquérez les compétences fondamentales nécessaires pour écrire un code Python clair et efficace.

Découvrez les principes fondamentaux des types de données numériques en Python et apprenez à manipuler les entiers et les nombres à virgule flottante. Maîtrisez les opérations arithmétiques de base, explorez le concept d'immuabilité et acquérez une expérience pratique avec les fonctions et outils intégrés de Python pour gérer efficacement les nombres dans des situations réelles.

Acquérir une compréhension claire du type de données booléen, un sous-type spécialisé des données numériques représentant les valeurs de vérité. Bien qu'il puisse sembler difficile au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous aidera à appliquer avec assurance la logique booléenne à des scénarios de programmation concrets.

Les chaînes de caractères permettent de travailler avec du texte en Python, qu'il s'agisse d'afficher des messages ou de traiter des saisies utilisateur. Vous étudierez comment créer, modifier et manipuler efficacement les chaînes de caractères. La compréhension des chaînes de caractères est essentielle pour écrire des programmes interactifs et transmettre clairement des informations dans votre code.

Apprenez à gérer efficacement les types de données afin d'assurer l'exactitude et la cohérence dans vos programmes. Conversion des valeurs au type approprié, nettoyage du texte avant comparaison et séparation des opérations numériques du formatage du texte. Découverte de la gestion délibérée des données manquantes et du traitement distinct du texte lisible par l'humain par rapport aux entrées brutes, pour obtenir des résultats fiables, cohérents et faciles à lire.

Défi : Exercices de Découpage et de Recherche

Solution

Défi : Exercices de Découpage et de Recherche

Solution