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

Verkrijg een grondig begrip van de kern-datatypen van Python en leer hoe u hier effectief mee kunt werken. Ontdek getallen, booleans en strings aan de hand van praktische oefeningen en voorbeelden. Bouw vertrouwen op in het uitvoeren van basisbewerkingen en ontwikkel de fundamentele vaardigheden die nodig zijn om duidelijke en efficiënte Python-code te schrijven.

Ontdek de basisprincipes van numerieke gegevenstypen in Python en leer werken met gehele getallen en drijvende-kommagetallen. Beheers elementaire rekenkundige bewerkingen, verken het concept van onveranderlijkheid en doe praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python om getallen efficiënt te verwerken in realistische situaties.

Verkrijg een duidelijk begrip van het Booleaanse gegevenstype, een gespecialiseerd subtype van numerieke gegevens dat waarheidswaarden weergeeft. Hoewel het in het begin uitdagend kan lijken, is het beheersen van Booleans essentieel voor het schrijven van logische en efficiënte programma's. Deze sectie helpt u om Booleaanse logica met vertrouwen toe te passen in praktische programmeersituaties.

Strings stellen je in staat om met tekst te werken in Python, van het weergeven van berichten tot het verwerken van gebruikersinvoer. Je onderzoekt hoe je strings effectief kunt aanmaken, wijzigen en manipuleren. Inzicht in strings is essentieel voor het schrijven van interactieve programma's en het duidelijk overbrengen van informatie via je code.

Leer hoe u datatypen effectief beheert om nauwkeurigheid en consistentie in uw programma's te waarborgen. Waarden omzetten naar het juiste type, tekst opschonen vóór vergelijking en numerieke bewerkingen scheiden van tekstformatering. U ontdekt ook hoe u ontbrekende gegevens doelbewust beheert en mensleesbare tekst anders behandelt dan ruwe invoer, wat resulteert in betrouwbare, consistente en gemakkelijk leesbare resultaten.

Uitdaging: Oefeningen met Slicing en Zoeken

Oplossing

Uitdaging: Oefeningen met Slicing en Zoeken

Oplossing