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

Opnå en solid forståelse af Pythons grundlæggende datatyper og lær at arbejde effektivt med dem. Udforsk tal, booleske værdier og strenge gennem praktiske øvelser og eksempler. Opbyg selvtillid i udførelsen af basale operationer og udvikl de grundlæggende færdigheder, der er nødvendige for at skrive ren og effektiv Python-kode.

Opdag det grundlæggende om numeriske datatyper i Python, og lær at arbejde med heltal og flydende kommatal. Få kendskab til grundlæggende aritmetiske operationer, undersøg begrebet uforanderlighed, og få praktisk erfaring med Pythons indbyggede funktioner og værktøjer til effektiv håndtering af tal i virkelige scenarier.

Opnå en klar forståelse af den booleske datatypen, en specialiseret undertype af numeriske data, der repræsenterer sandhedsværdier. Selvom det kan virke udfordrende i starten, er beherskelse af booleske værdier afgørende for at skrive logiske og effektive programmer. Dette afsnit vil hjælpe dig med sikkert at anvende boolesk logik i virkelige programmeringssituationer.

Strenge giver mulighed for at arbejde med tekst i Python, fra visning af beskeder til behandling af brugerinput. Du vil undersøge, hvordan man opretter, ændrer og manipulerer strenge effektivt. Forståelse af strenge er afgørende for at skrive interaktive programmer og formidle information tydeligt gennem din kode.

Lær at håndtere datatyper effektivt for at sikre nøjagtighed og konsistens i dine programmer. Konverter værdier til den passende type, rens tekst før sammenligning, og adskil numeriske operationer fra tekstformatering. Du vil også opdage, hvordan man bevidst håndterer manglende data og behandler menneskelæsbar tekst anderledes end rå input, hvilket giver pålidelige, konsistente og letlæselige resultater.

Udfordring: Øvelser i Udskæring og Søgning

Løsning

Udfordring: Øvelser i Udskæring og Søgning

Løsning