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

Erwerben Sie ein fundiertes Verständnis der grundlegenden Datentypen in Python und lernen Sie, wie Sie effektiv mit ihnen arbeiten. Erkunden Sie Zahlen, Boolesche Werte und Zeichenketten anhand praxisorientierter Übungen und Beispiele. Stärken Sie Ihr Vertrauen in die Durchführung grundlegender Operationen und entwickeln Sie die notwendigen Grundlagen, um sauberen und effizienten Python-Code zu schreiben.

Erkunden Sie die Grundlagen der numerischen Datentypen in Python und erfahren Sie, wie Sie mit Ganzzahlen und Gleitkommazahlen arbeiten. Beherrschen Sie grundlegende arithmetische Operationen, untersuchen Sie das Konzept der Unveränderlichkeit und sammeln Sie praktische Erfahrungen mit den integrierten Funktionen und Werkzeugen von Python, um Zahlen effizient in realen Szenarien zu verarbeiten.

Erhalten Sie ein klares Verständnis des Boolean-Datentyps, einer spezialisierten Unterkategorie numerischer Daten, die Wahrheitswerte repräsentiert. Obwohl der Einstieg zunächst herausfordernd erscheinen mag, ist das Beherrschen von Booleans unerlässlich für das Schreiben logischer und effizienter Programme. Dieser Abschnitt unterstützt Sie dabei, Boolesche Logik sicher in praxisnahen Programmieraufgaben anzuwenden.

Zeichenketten ermöglichen die Arbeit mit Text in Python, von der Anzeige von Nachrichten bis zur Verarbeitung von Benutzereingaben. Sie werden untersuchen, wie Zeichenketten erstellt, verändert und effektiv manipuliert werden können. Das Verständnis von Zeichenketten ist unerlässlich, um interaktive Programme zu schreiben und Informationen klar durch Ihren Code zu vermitteln.

Erfahren Sie, wie verschiedene Datentypen effektiv gehandhabt werden, um Genauigkeit und Konsistenz in Programmen sicherzustellen. Werte in den passenden Typ umwandeln, Text vor Vergleichen bereinigen und numerische Operationen von der Textformatierung trennen. Zudem wird gezeigt, wie fehlende Daten gezielt verwaltet und menschenlesbarer Text anders als Rohdaten behandelt werden, um zuverlässige, konsistente und gut lesbare Ergebnisse zu erzielen.

Herausforderung: Übungen zu Slicing und Suche

Lösung

Herausforderung: Übungen zu Slicing und Suche

Lösung