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

A focused, beginner-friendly course on working with numbers in Python. Learn about integers, floats, arithmetic operations, type conversion, and how to avoid common pitfalls when handling numerical data.

Challenge: Slicing and Search Drills

Ratkaisu