import importlib
import unittest


class TestUserCode(unittest.TestCase):

    def _test_variable_equals_string(self, var_name, expected):
        # Force local import and reload to prevent module caching across runs
        import user_code

        importlib.reload(user_code)

        if not hasattr(user_code, var_name):
            return (False, f"Expected '{var_name}' variable to be defined.")

        var = getattr(user_code, var_name)
        if var != expected:
            return (
                False,
                f"Expected '{var_name}' to equal '{expected}', but got '{var}'.",
            )
        return (True, f'The variable {var_name} equals "{expected}"')

    def _assert_dynamic(self, var_name, expected):
        """Processes the validation and dynamically updates the test reporter name."""
        passed, result_text = self._test_variable_equals_string(
            var_name, expected
        )
        self._testMethodName = result_text
        self.assertTrue(passed, result_text)

    # --- Dynamic Test Cases ---

    def test_learn(self):
        self._assert_dynamic("learn", "learn")

    def test_painful(self):
        self._assert_dynamic("painful", "painful")

    def test_mistakes(self):
        self._assert_dynamic("mistakes", "mistakes")


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

test_main.py

Verkrijg een grondig begrip van de kern-datatypen van Python en leer hoe u er effectief mee kunt werken. Ontdek getallen, booleans, strings en hoe u waarden veilig kunt converteren en vergelijken tussen verschillende typen. Bouw vertrouwen op in het uitvoeren van rekenkundige, logische en stringbewerkingen, en ontwikkel de basisvaardigheden die nodig zijn om schone, betrouwbare Python-code te schrijven.

Ontdek de basisprincipes van numerieke types in Python, van gehele getallen en kommagetallen tot rekenkundige bewerkingen en operatorprioriteit. Oefen met gehele deling, modulo en functies uit de math-module aan de hand van praktijkvoorbeelden zoals tijds- en budgetberekeningen.

Verkrijg een grondig begrip van het Booleaanse gegevenstype en hoe vergelijkingsoperatoren gelijkheid, identiteit en waarheidswaarden evalueren.
Toepassing van logische operatoren voor het opstellen van duidelijke, nauwkeurige condities in realistische programmeerscenario's.



Praktische ervaring met Python-strings, van het aanmaken en indexeren tot het slicen, zoeken en formatteren van tekst. Inzicht in de onveranderlijkheid van strings en het efficiënt opbouwen van nieuwe strings voor interactieve programma's.



Ontdek hoe u kunt converteren tussen de kern-datatypen van Python, strings betrouwbaar kunt vergelijken door hoofdletters en witruimte te normaliseren, en ontbrekende waarden kunt afhandelen met None. Leer wanneer u bytes en bytearray gebruikt voor ruwe binaire gegevens in praktijktoepassingen.



Uitdaging: Slicen met Indexfunctie

Oplossing