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, 'sample_text'),
            "The `sample_text` variable is declared.",
            "Expected `sample_text` variable to be declared."
        )

    def test_test_str_value_correct(self):
        import user_code
        expected_value = "This is a string for learning"
        actual_value = user_code.sample_text
        _dynamic_test(
            self,
            actual_value == expected_value,
            f"The `sample_text` variable contains `{expected_value}`.",
            f"Expected `sample_text` 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.sample_text[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.sample_text[-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 = "for"
        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 `for`.",
            "Expected string slicing to be used to extract `for`."
        )

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

test_main.py

Python is an interpreted high-level general-purpose programming language. Unlike HTML, CSS, and JavaScript, which are primarily used for web development, Python is versatile and can be used in various fields, including software development, data science, and back-end development. In this course, you'll explore the core aspects of Python, and by the end, you'll be crafting your own functions!

Dive into the basics of Python, explore your workspace, and perform simple math operations. Learn how to write readable code using comments and handle both basic and advanced mathematical expressions while displaying your results.

Learn how to store and manage data in Python by working with numbers, text, and variables. Understand how to assign values, follow naming conventions, and explore different data types. Gain hands-on experience with string operations, indexing, slicing, and memory recall techniques to efficiently manipulate text in Python.

Learn how to use comparison and logical operators, work with conditional expressions, and apply membership and type comparisons. Build a strong foundation in writing programs that respond dynamically to different conditions using if/else and if/elif/else structures.

Expand your understanding of data types by learning how to group multiple attributes within a single variable. Explore lists, tuples, and dictionaries to efficiently store and manage structured data, along with essential methods for manipulation and retrieval.

Master the art of writing loops in Python—essential constructs for iterating over lists, tuples, dictionaries, and other data structures. Learn to use while and for loops effectively, explore the range function, and work with nested loops to handle complex iteration patterns.

Explore essential built-in functions in Python and take the next step by creating your own. Learn how to define functions, use conditional logic, modify existing functions, and work with lambda expressions to write efficient, reusable code.

Which of these is a correct way to create a variable?

How do you store the text `"Hello"` in a variable named `greeting`?

Which of these variable names is valid in Python?

What is the correct way to output `"c<>definity"` in the console?

How can you convert the string `"123"` to an integer?

What will happen when the following code is executed?

Challenge: Retrieving Letters from String

Oplossing

Awesome!

Challenge: Retrieving Letters from String

Oplossing