import unittest
import importlib
import re

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 TestStringIndexing(unittest.TestCase):

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

    def test_test_str_value_correct(self):
        import user_code
        expected_value = "This is string for learning"
        actual_value = user_code.test_str
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `test_str` variable contains `{expected_value}`.",
            f"Expected `test_str` to be `{expected_value}`, but got `{actual_value}`."
        )

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

    def test_first_char_value_correct(self):
        import user_code
        expected_value = user_code.test_str[0]
        actual_value = user_code.first_char
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `first_char` variable contains `{expected_value}`.",
            f"Expected `first_char` to be `{expected_value}`, but got `{actual_value}`."
        )

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

    def test_last_char_value_correct(self):
        import user_code
        expected_value = user_code.test_str[-1]
        actual_value = user_code.last_char
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `last_char` variable contains `{expected_value}`.",
            f"Expected `last_char` to be `{expected_value}`, but got `{actual_value}`."
        )

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

    def test_highlighted_word_value_correct(self):
        import user_code
        expected_value = "learning"
        actual_value = user_code.highlighted_word
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `highlighted_word` variable contains `{expected_value}`.",
            f"Expected `highlighted_word` to be `{expected_value}`, but got `{actual_value}`."
        )

    def test_indexing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\[\d+\]', user_code_source) and re.search(r'\[-\d+\]', user_code_source),
            "Indexing is used to extract characters from the string.",
            "Expected indexing to be used to extract characters from the string."
        )

    def test_slicing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\[.*:.*\]', user_code_source),
            "String slicing is used to extract `learning`.",
            "Expected string slicing to be used to extract `learning`."
        )

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


test_main.py

Python es un lenguaje de programación interpretado de alto nivel y de propósito general. A diferencia de HTML, CSS y JavaScript, que se utilizan principalmente para el desarrollo web, Python es más versátil y se puede utilizar en diversos campos, incluyendo el desarrollo de software, ciencia de datos, y el desarrollo de back-end. En este curso, explorarás los aspectos básicos de Python y, al final, ¡crearás tus propias funciones!

En esta sección, aprenderás los conceptos básicos de Python, te familiarizarás con tu espacio de trabajo, abordarás operaciones matemáticas sencillas y mostrarás tus resultados.

Aquí, aprenderás cómo almacenar elementos como números y texto en la memoria de la computadora, recordándolos por nombre. También tendrás una idea de la manipulación de texto en Python.

Aquí, profundizarás en el tipo de dato booleano y descubrirás su papel en la creación de programas que responden a condiciones específicas.

Continuando con los tipos de datos, esta sección te enseñará cómo agrupar atributos variados dentro de una sola variable usando listas, tuplas y diccionarios.

En esta parte, dominarás el arte de escribir Loops (Bucles) en Python - construcciones esenciales para iterar sobre lists, tuples, dictionaries, e incluso futuros dataframes.

Para concluir nuestro curso introductorio, exploraremos algunas funciones incorporadas y, a continuación, nos embarcaremos en la creación de nuestras propias funciones.

¿Cuál de estos es una forma correcta de crear una variable?

¿Cómo almacenas el texto `"Hello"` en una variable llamada `greeting`?

¿Cuál de estos nombres de variables es válido en Python?

¿Cuál es la forma correcta de mostrar `"c<>definity"` en la consola?

¿Cómo puedes convertir la cadena `"123"` a un entero?

¿Qué sucederá cuando se ejecute el siguiente código?

Desafío: Recuperar Letras de una Cadena

Solución

Desafío: Recuperar Letras de una Cadena

Solución