import unittest
import importlib
import io
from contextlib import redirect_stdout
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 TestPeopleInformationFunction(unittest.TestCase):

    def test_people_information_function_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'people_information_mod') and callable(user_code.people_information_mod),
            "The `people_information_mod` function is declared.",
            "Expected `people_information_mod` function to be declared."
        )

    def test_people_information_correct_output_for_existing_key(self):
        import user_code
        people_d = {'Alex': (23, 178), 'Noah': (34, 189), 'Peter': (29, 175), 'John': (41, 185), 'Michelle': (35, 165)}

        f = io.StringIO()
        with redirect_stdout(f):
            user_code.people_information_mod(people_d, "Alex")
        output = f.getvalue().strip()

        expected_output = "Name: Alex\\nAge: 23 y.o.\\nHeight: 178 cm"
        _dynamic_test(
            self,
            re.sub(r'\s+', ' ', output) == re.sub(r'\s+', ' ', expected_output),
            "The `people_information_mod` function correctly prints information for `Alex`.",
            f"Expected output for `Alex`: `{expected_output}`, but got `{output}`."
        )

    def test_people_information_correct_output_for_non_existing_key(self):
        import user_code
        people_d = {'Alex': (23, 178), 'Noah': (34, 189), 'Peter': (29, 175), 'John': (41, 185), 'Michelle': (35, 165)}

        f = io.StringIO()
        with redirect_stdout(f):
            user_code.people_information_mod(people_d, "Richard")
        output = f.getvalue().strip()

        expected_output = "There is no information about Richard"
        _dynamic_test(
            self,
            re.sub(r'\s+', ' ', output) == re.sub(r'\s+', ' ', expected_output),
            "The `people_information_mod` function correctly handles missing keys.",
            f"Expected output for missing key `Richard`: `{expected_output}`, but got `{output}`."
        )

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


test_main.py

Python is een geïnterpreteerde, hoog-niveau, algemene programmeertaal. In tegenstelling tot HTML, CSS en JavaScript, die voornamelijk worden gebruikt voor webontwikkeling, is Python veelzijdig en kan het worden gebruikt in verschillende velden, waaronder softwareontwikkeling, datawetenschap en back-end ontwikkeling. In deze cursus verken je de kernaspecten van Python, en aan het einde zul je je eigen functies maken!

Duik in de basisprincipes van Python, verken je werkruimte en voer eenvoudige wiskundige bewerkingen uit. Leer hoe je leesbare code schrijft met behulp van opmerkingen en hoe je zowel basis- als geavanceerde wiskundige uitdrukkingen kunt verwerken terwijl je je resultaten weergeeft.

Leer hoe je gegevens kunt opslaan en beheren in Python door te werken met getallen, tekst en variabelen. Begrijp hoe je waarden toewijst, naamgevingsconventies volgt en verschillende gegevenstypen verkent. Krijg praktische ervaring met stringbewerkingen, indexering, slicing en geheugenherinneringstechnieken om efficiënt tekst in Python te manipuleren.

Leer hoe je vergelijkings- en logische operatoren gebruikt, werkt met voorwaardelijke expressies, en lidmaatschap- en typevergelijkingen toepast. Bouw een sterke basis in het schrijven van programma's die dynamisch reageren op verschillende voorwaarden met behulp van if/else en if/elif/else structuren.

Breid je begrip van gegevenstypen uit door te leren hoe je meerdere attributen binnen een enkele variabele kunt groeperen. Verken lists, tuples en dictionaries om gestructureerde gegevens efficiënt op te slaan en te beheren, samen met essentiële methoden voor manipulatie en opvraging.

Beheers de kunst van het schrijven van loops in Python—essentiële constructies voor het itereren over lijsten, tuples, dictionaries en andere datastructuren. Leer effectief gebruik te maken van while- en for-loops, verken de range-functie en werk met geneste loops om complexe iteratiepatronen te beheren.

Ontdek essentiële ingebouwde functies in Python en zet de volgende stap door je eigen functies te maken. Leer hoe je functies definieert, voorwaardelijke logica gebruikt, bestaande functies aanpast en werkt met lambda-expressies om efficiënte, herbruikbare code te schrijven.

Uitdaging: Bijwerken van de Logica van de Function

Oplossing

Uitdaging: Bijwerken van de Logica van de Function

Oplossing