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

Acquisisci una solida comprensione dei principali tipi di dati di Python e impara a utilizzarli in modo efficace. Esplora numeri, booleani e stringhe attraverso esercizi pratici ed esempi concreti. Sviluppa sicurezza nell'esecuzione delle operazioni di base e costruisci le competenze fondamentali necessarie per scrivere codice Python pulito ed efficiente.

Scopri le nozioni fondamentali dei tipi di dati numerici in Python e apprendi come lavorare con numeri interi e numeri in virgola mobile. Acquisisci padronanza delle operazioni aritmetiche di base, esplora il concetto di immutabilità e ottieni esperienza pratica utilizzando le funzioni e gli strumenti integrati di Python per gestire i numeri in modo efficiente in scenari reali.

Acquisisci una comprensione chiara del tipo di dato booleano, un sottotipo specializzato dei dati numerici che rappresenta valori di verità. Sebbene possa sembrare complesso inizialmente, padroneggiare i booleani è fondamentale per scrivere programmi logici ed efficienti. Questa sezione ti aiuterà ad applicare con sicurezza la logica booleana in scenari di programmazione reali.

Le stringhe consentono di lavorare con il testo in Python, dalla visualizzazione di messaggi all'elaborazione dell'input dell'utente. Verrà illustrato come creare, modificare e manipolare le stringhe in modo efficace. La comprensione delle stringhe è fondamentale per scrivere programmi interattivi e comunicare informazioni in modo chiaro attraverso il codice.

Scopri come gestire efficacemente i tipi di dati per garantire accuratezza e coerenza nei tuoi programmi. Conversione dei valori al tipo appropriato, pulizia del testo prima del confronto e separazione delle operazioni numeriche dalla formattazione del testo. Verrà inoltre illustrata la gestione intenzionale dei dati mancanti e il trattamento differenziato del testo leggibile rispetto all'input grezzo, ottenendo risultati affidabili, coerenti e di facile lettura.

Sfida: Esercizi su Slicing e Ricerca

Soluzione

Sfida: Esercizi su Slicing e Ricerca

Soluzione