Bereit, das bisher Gelernte in die **Praxis** umzusetzen? Diese Aufgabe erfordert die Anwendung der Operatoren `and`, `or` und `not` sowie von **booleschen Vergleichsoperatoren**, um ein komplexes Szenario für einen Lebensmittelladen zu steuern.

Los geht's!


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 ist eine hochentwickelte, interpretierte, universell einsetzbare Programmiersprache. Im Gegensatz zu Sprachen wie HTML, CSS und JavaScript, die hauptsächlich in der Webentwicklung verwendet werden, zeichnet sich Python durch Vielseitigkeit in verschiedenen Bereichen wie Softwareentwicklung, Data Science und Back-End-Entwicklung aus. Dieser Kurs führt Sie durch die grundlegenden Konzepte von Python und vermittelt Ihnen die Fähigkeiten, eigene Funktionen zu erstellen.

In diesem Abschnitt werden die Grundlagen von Python behandelt.
Sie lernen Ihre Arbeitsumgebung kennen, führen einfache mathematische Operationen durch und geben Ihre Ergebnisse aus.

In diesem Abschnitt erfahren Sie, wie Sie Elemente wie Zahlen und Text im Computerspeicher speichern und sie anhand ihres Namens abrufen können. Zusätzlich erhalten Sie eine Einführung in die Textmanipulation in Python.

In diesem Abschnitt werden Sie den booleschen Datentyp untersuchen und erfahren, wie er verwendet wird,
um Programme zu entwickeln, die auf bestimmte Bedingungen reagieren.

In diesem Abschnitt werden Sie weiterhin Datentypen kennenlernen und erfahren,
wie verschiedene Attribute in einer einzigen Variablen mithilfe von Listen, Tupeln und Dictionaries organisiert werden können.

In diesem Abschnitt lernen Sie, wie man Schleifen in Python erstellt — eine grundlegende Fähigkeit
zum Iterieren durch Listen, Tupel und Dictionaries.

Zum Abschluss dieses Einführungskurses werden einige eingebaute Funktionen untersucht und anschließend eigene entwickelt.

Herausforderung: Boolesche Logik

Ausgabebedingungen

Lösung

Awesome!

Herausforderung: Boolesche Logik

Ausgabebedingungen

Lösung