Summary  
This chapter covers Python’s string slicing syntax, showing how to extract substrings by specifying start, end, and step indices and how to use open-ended slicing patterns. It explains both fixed-range slicing and omitting components for flexible extraction.

General domain of usage  
Text processing

import unittest

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)


class TestUserCode(unittest.TestCase):
    # Expected values based on the given starter data
    EXP_NAME_CLEAN = "Ada Lovelace"
    EXP_HAS_QUICK = True
    EXP_INSIDE_PARENS = "quick"
    EXP_O_COUNT = 4
    EXP_DOMAIN = "example.com"
    EXP_SEP = " | "
    EXP_REPORT = f"{EXP_NAME_CLEAN}{EXP_SEP}{EXP_DOMAIN}{EXP_SEP}{EXP_O_COUNT}"

    def test_name_clean_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "name_clean"),
            "The `name_clean` variable is declared.",
            "Expected `name_clean` to be declared."
        )

    def test_name_clean_value(self):
        import user_code
        try:
            actual = user_code.name_clean
            condition = actual == self.EXP_NAME_CLEAN
            failure = f"Expected `name_clean` to be `{self.EXP_NAME_CLEAN}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `name_clean` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `name_clean` value is `{self.EXP_NAME_CLEAN}`.",
            failure
        )

    def test_has_quick_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "has_quick"),
            "The `has_quick` variable is declared.",
            "Expected `has_quick` to be declared."
        )

    def test_has_quick_value(self):
        import user_code
        try:
            actual = user_code.has_quick
            condition = actual == self.EXP_HAS_QUICK
            failure = f"Expected `has_quick` to be `{self.EXP_HAS_QUICK}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `has_quick` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `has_quick` value is `{self.EXP_HAS_QUICK}`.",
            failure
        )

    def test_inside_parens_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "inside_parens"),
            "The `inside_parens` variable is declared.",
            "Expected `inside_parens` to be declared."
        )

    def test_inside_parens_value(self):
        import user_code
        try:
            actual = user_code.inside_parens
            condition = actual == self.EXP_INSIDE_PARENS
            failure = f"Expected `inside_parens` to be `{self.EXP_INSIDE_PARENS}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `inside_parens` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `inside_parens` value is `{self.EXP_INSIDE_PARENS}`.",
            failure
        )

    def test_o_count_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "o_count"),
            "The `o_count` variable is declared.",
            "Expected `o_count` to be declared."
        )

    def test_o_count_value(self):
        import user_code
        try:
            actual = user_code.o_count
            condition = actual == self.EXP_O_COUNT
            failure = f"Expected `o_count` to be `{self.EXP_O_COUNT}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `o_count` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `o_count` value is `{self.EXP_O_COUNT}`.",
            failure
        )

    def test_domain_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "domain"),
            "The `domain` variable is declared.",
            "Expected `domain` to be declared."
        )

    def test_domain_value(self):
        import user_code
        try:
            actual = user_code.domain
            condition = actual == self.EXP_DOMAIN
            failure = f"Expected `domain` to be `{self.EXP_DOMAIN}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `domain` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `domain` value is `{self.EXP_DOMAIN}`.",
            failure
        )

    def test_report_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "report"),
            "The `report` variable is declared.",
            "Expected `report` to be declared."
        )

    def test_report_value(self):
        import user_code
        try:
            actual = user_code.report
            condition = actual == self.EXP_REPORT
            failure = f"Expected `report` to be `{self.EXP_REPORT}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `report` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `report` value is `{self.EXP_REPORT}`.",
            failure
        )


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


test_main.py

Acquérir une compréhension approfondie des principaux types de données en Python et apprendre à les manipuler efficacement. Explorer les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développer la confiance dans l'exécution des opérations de base et acquérir 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’immutabilité 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.

Compréhension approfondie 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 complexe au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous permettra d'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 des 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 à travers votre code.

Apprenez à gérer efficacement les types de données afin d'assurer l'exactitude et la cohérence dans vos programmes. Convertir les valeurs au type approprié, nettoyer le texte avant la comparaison et séparer les opérations numériques du formatage du texte. Vous découvrirez également comment gérer délibérément les données manquantes et traiter différemment le texte lisible par l'humain des entrées brutes, afin d'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