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
import importlib

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")

        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}"

    # 1) name_clean
    def test_name_clean(self):
        ok = (
            hasattr(self.m, "name_clean") and
            self.m.name_clean == self.exp_name_clean
        )

        _dynamic_test(
            self,
            ok,
            "name_clean computed correctly",
            "name_clean computed incorrectly"
        )

    # 2) has_quick AND o_count
    def test_has_quick_and_o_count(self):
        try:
            has_quick = self.m.has_quick
            o_count = self.m.o_count
        except Exception:
            _dynamic_test(
                self,
                False,
                "has_quick and o_count computed correctly",
                "Missing has_quick or o_count variables"
            )
            return

        cond = (
            has_quick == self.exp_has_quick and
            o_count == self.exp_o_count
        )

        _dynamic_test(
            self,
            cond,
            "has_quick and o_count computed correctly",
            "has_quick or o_count computed incorrectly"
        )

    # 3) inside_parens
    def test_inside_parens(self):
        try:
            inside = self.m.inside_parens
            sentence = self.m.sentence
            start = self.m.start
            end = self.m.end
        except Exception:
            _dynamic_test(
                self,
                False,
                "inside_parens computed correctly",
                "inside_parens or index variables missing"
            )
            return

        cond = (
            inside == self.exp_inside_parens and
            isinstance(start, int) and
            isinstance(end, int) and
            0 <= start < end <= len(sentence) and
            sentence[start + 1 : end] == inside
        )

        _dynamic_test(
            self,
            cond,
            "inside_parens computed correctly",
            "inside_parens computed incorrectly"
        )

    # 4) domain
    def test_domain(self):
        try:
            domain = self.m.domain
        except Exception:
            _dynamic_test(
                self,
                False,
                "domain computed correctly",
                "domain variable missing"
            )
            return

        cond = domain == self.exp_domain

        _dynamic_test(
            self,
            cond,
            "domain computed correctly",
            "domain computed incorrectly"
        )

    # 5) report
    def test_report(self):
        try:
            report = self.m.report
        except Exception:
            _dynamic_test(
                self,
                False,
                "report computed correctly",
                "report variable missing"
            )
            return

        cond = report == self.exp_report

        _dynamic_test(
            self,
            cond,
            "report computed correctly",
            "report computed incorrectly"
        )


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


test_main.py

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

Challenge: Slicing and Search Drills

解答