Klaar om alles wat je hebt geleerd in de **praktijk** te brengen? Deze uitdaging vereist het gebruik van de `and`, `or` en `not` **operatoren** evenals **booleaanse vergelijkingsoperatoren** om een complex scenario voor een supermarkt te beheren.

Laten we beginnen!


import unittest
import importlib
import io
from contextlib import redirect_stdout
import re
import inspect
import user_code


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)


def strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.strip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestMakeDiscountLogic(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?])\s*', r'\1 ', text)
        return text.strip()

    def test_overstockRisk_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'overstock_risk') and user_code.overstock_risk is True,
            "overstock_risk is correctly set to True",
            f"Expected overstock_risk to be True, got {getattr(user_code, 'overstock_risk', None)}"
        )

    def test_discountEligible_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'discount_eligible') and user_code.discount_eligible is True,
            "discount_eligible is correctly set to True",
            f"Expected discount_eligible to be True, got {getattr(user_code, 'discount_eligible', None)}"
        )

    def test_makeDiscount_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'make_discount') and user_code.make_discount is True,
            "make_discount is correctly set to True",
            f"Expected make_discount to be True, got {getattr(user_code, 'make_discount', None)}"
        )

    def test_print_output(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("Should the item be discounted? True")
        _dynamic_test(
            self,
            expected in output,
            "Print output is correct",
            f"Expected output to include: '{expected}', got: '{output}'"
        )

    def test_or_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+or\s+', source) is not None,
            "'or' operator is used in the code",
            "Expected use of 'or' logical operator"
        )

    def test_and_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+and\s+', source) is not None,
            "'and' operator is used in the code",
            "Expected use of 'and' logical operator"
        )

    def test_not_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+not\s+', source) is not None,
            "'not' operator is used in the code",
            "Expected use of 'not' logical operator"
        )


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

test_main.py

Python is een high-level, geïnterpreteerde, general-purpose programmeertaal. In tegenstelling tot talen zoals HTML, CSS en JavaScript, die voornamelijk worden gebruikt voor webontwikkeling, onderscheidt Python zich door zijn veelzijdigheid in meerdere domeinen, waaronder softwareontwikkeling, data science en back-end ontwikkeling. Deze cursus leidt je door de fundamentele concepten van Python en voorziet je van de vaardigheden om aan het einde van het programma je eigen functies te creëren.

In deze sectie maak je kennis met de basisprincipes van Python, raak je vertrouwd met je werkomgeving, voer je eenvoudige wiskundige bewerkingen uit en toon je je bevindingen.

In deze sectie ontdekt u hoe u items zoals getallen en tekst in het computergeheugen kunt opslaan en deze kunt ophalen via hun naam. Daarnaast krijgt u een introductie tot tekstmanipulatie in Python.

In deze sectie maak je kennis met het booleaanse gegevenstype en leer je hoe dit wordt gebruikt om programma's te ontwikkelen die reageren op bepaalde voorwaarden.

In deze sectie leert u verder over gegevenstypen en ontdekt u hoe u verschillende attributen in één variabele kunt organiseren met behulp van lijsten, tuples en woordenboeken.

In deze sectie leert u hoe u lussen maakt in Python — een essentiële vaardigheid voor het itereren door lijsten, tuples en woordenboeken.

Ter afsluiting van deze inleidende cursus maak je kennis met enkele ingebouwde functies en begin je met het ontwikkelen van eigen functies.

Uitdaging: Booleaanse Logica

Uitvoervereisten

Oplossing

Awesome!

Uitdaging: Booleaanse Logica

Uitvoervereisten

Oplossing