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

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    # Expected values based on the given starter data
    EXP_NAME_CLEAN = "Ada Lovelace"
    EXP_HAS_QUICK = True
    EXP_INSIDE_PARENS = "quick"
    EXP_O_COUNT = 4
    EXP_DOMAIN = "example.com"
    EXP_SEP = " | "
    EXP_REPORT = f"{EXP_NAME_CLEAN}{EXP_SEP}{EXP_DOMAIN}{EXP_SEP}{EXP_O_COUNT}"

    def test_name_clean_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "name_clean"),
            "The `name_clean` variable is declared.",
            "Expected `name_clean` to be declared."
        )

    def test_name_clean_value(self):
        import user_code
        try:
            actual = user_code.name_clean
            condition = actual == self.EXP_NAME_CLEAN
            failure = f"Expected `name_clean` to be `{self.EXP_NAME_CLEAN}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `name_clean` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `name_clean` value is `{self.EXP_NAME_CLEAN}`.",
            failure
        )

    def test_has_quick_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "has_quick"),
            "The `has_quick` variable is declared.",
            "Expected `has_quick` to be declared."
        )

    def test_has_quick_value(self):
        import user_code
        try:
            actual = user_code.has_quick
            condition = actual == self.EXP_HAS_QUICK
            failure = f"Expected `has_quick` to be `{self.EXP_HAS_QUICK}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `has_quick` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `has_quick` value is `{self.EXP_HAS_QUICK}`.",
            failure
        )

    def test_inside_parens_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "inside_parens"),
            "The `inside_parens` variable is declared.",
            "Expected `inside_parens` to be declared."
        )

    def test_inside_parens_value(self):
        import user_code
        try:
            actual = user_code.inside_parens
            condition = actual == self.EXP_INSIDE_PARENS
            failure = f"Expected `inside_parens` to be `{self.EXP_INSIDE_PARENS}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `inside_parens` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `inside_parens` value is `{self.EXP_INSIDE_PARENS}`.",
            failure
        )

    def test_o_count_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "o_count"),
            "The `o_count` variable is declared.",
            "Expected `o_count` to be declared."
        )

    def test_o_count_value(self):
        import user_code
        try:
            actual = user_code.o_count
            condition = actual == self.EXP_O_COUNT
            failure = f"Expected `o_count` to be `{self.EXP_O_COUNT}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `o_count` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `o_count` value is `{self.EXP_O_COUNT}`.",
            failure
        )

    def test_domain_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "domain"),
            "The `domain` variable is declared.",
            "Expected `domain` to be declared."
        )

    def test_domain_value(self):
        import user_code
        try:
            actual = user_code.domain
            condition = actual == self.EXP_DOMAIN
            failure = f"Expected `domain` to be `{self.EXP_DOMAIN}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `domain` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `domain` value is `{self.EXP_DOMAIN}`.",
            failure
        )

    def test_report_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "report"),
            "The `report` variable is declared.",
            "Expected `report` to be declared."
        )

    def test_report_value(self):
        import user_code
        try:
            actual = user_code.report
            condition = actual == self.EXP_REPORT
            failure = f"Expected `report` to be `{self.EXP_REPORT}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure = "Expected `report` to be declared."
        _dynamic_test(
            self,
            condition,
            f"The `report` value is `{self.EXP_REPORT}`.",
            failure
        )


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


test_main.py

Adquiera una comprensión sólida de los tipos de datos fundamentales de Python y aprenda a utilizarlos de manera eficaz. Explore números, booleanos y cadenas mediante ejercicios prácticos y ejemplos aplicados. Desarrolle confianza al realizar operaciones básicas y consolide las habilidades esenciales para escribir código Python limpio y eficiente.

Descubra los aspectos esenciales de los tipos de datos numéricos en Python y aprenda a trabajar con enteros y números de punto flotante. Domine las operaciones aritméticas básicas, explore el concepto de inmutabilidad y adquiera experiencia práctica utilizando las funciones y herramientas integradas de Python para manejar números de manera eficiente en escenarios reales.

Obtén una comprensión clara del tipo de dato booleano, un subtipo especializado de datos numéricos que representa valores de verdad. Aunque puede parecer desafiante al principio, dominar los booleanos es esencial para escribir programas lógicos y eficientes. Esta sección te ayudará a aplicar con confianza la lógica booleana en escenarios de programación del mundo real.

Las cadenas de texto permiten trabajar con información textual en Python, desde mostrar mensajes hasta procesar la entrada del usuario. Se explorará cómo crear, modificar y manipular cadenas de manera eficaz. Comprender las cadenas de texto es fundamental para escribir programas interactivos y comunicar información de forma clara a través del código.

Aprenda a manejar los tipos de datos de manera efectiva para garantizar la precisión y coherencia en sus programas. Convierta valores al tipo adecuado, limpie el texto antes de la comparación y separe las operaciones numéricas del formato de texto. También descubrirá cómo gestionar datos faltantes de forma deliberada y tratar el texto legible para humanos de manera diferente al ingreso sin procesar, logrando resultados fiables, coherentes y fáciles de leer.

Desafío: Ejercicios de Segmentación y Búsqueda

Solución

Desafío: Ejercicios de Segmentación y Búsqueda

Solución