Bereit, alles, was Sie gelernt haben, in die **Praxis** umzusetzen? Diese Herausforderung erfordert, dass Sie die `and`, `or` und `not` **Operatoren** sowie **boolesche Vergleichsoperatoren** verwenden, um ein komplexes Szenario für ein Lebensmittelgeschäft zu verwalten.

Lassen Sie uns eintauchen!


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

class TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_overstockRisk_defined(self):
        self._testMethodName = 'overstockRisk is defined'
        self.assertTrue(hasattr(user_code, 'overstockRisk'), "Expected overstockRisk to be defined.")

    def test_overstockRisk_uses_and_operator(self):
        self._testMethodName = 'overstockRisk uses logical and operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        self.assertRegex(code, r'overstockRisk\\s*=\\s*.*\\band\\b.*', "Expected overstockRisk to be defined using 'and' operator.")

    def test_overstockRisk_correct(self):
        self._testMethodName = 'overstockRisk has correct value'
        expected = user_code.seasonal and user_code.current_stock > user_code.high_stock_threshold
        self.assertEqual(user_code.overstockRisk, expected, f"Expected overstockRisk to be {expected}, but got {user_code.overstockRisk}.")

    def test_discountEligible_defined(self):
        self._testMethodName = 'discountEligible is defined'
        self.assertTrue(hasattr(user_code, 'discountEligible'), "Expected discountEligible to be defined.")

    def test_discountEligible_uses_not_and_operator(self):
        self._testMethodName = 'discountEligible uses logical not and operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        self.assertRegex(code, r'discountEligible\\s*=\\s*\\bnot\\b.*\\s*selling_well\\s*.*and\\s*\\bnot\\b.*\\s*on_sale', "Expected discountEligible to be defined using 'not selling_well and not on_sale'.")

    def test_discountEligible_correct(self):
        self._testMethodName = 'discountEligible has correct value'
        expected = (not user_code.selling_well) and (not user_code.on_sale)
        self.assertEqual(user_code.discountEligible, expected, f"Expected discountEligible to be {expected}, but got {user_code.discountEligible}.")

    def test_makeDiscount_defined(self):
        self._testMethodName = 'makeDiscount is defined'
        self.assertTrue(hasattr(user_code, 'makeDiscount'), "Expected makeDiscount to be defined.")

    def test_makeDiscount_uses_or_operator(self):
        self._testMethodName = 'makeDiscount uses logical or operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        self.assertRegex(code, r'makeDiscount\\s*=\\s*.*\\bor\\b.*', "Expected makeDiscount to be defined using 'or' operator.")

    def test_makeDiscount_correct(self):
        self._testMethodName = 'makeDiscount has correct value'
        expected = user_code.overstockRisk or user_code.discountEligible
        self.assertEqual(user_code.makeDiscount, expected, f"Expected makeDiscount to be {expected}, but got {user_code.makeDiscount}.")

    def test_print_output_correct(self):
        self._testMethodName = 'Printed output is correct'
        f = StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue().strip())
        expected_output = self.normalize_text(f"Should the item be discounted? {user_code.makeDiscount}")
        self.assertEqual(output, expected_output, f"Expected print output to be '{expected_output}', but got '{output}'.")

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

test_main.py

Python ist eine hochentwickelte, interpretierte, universelle Programmiersprache. Im Gegensatz zu Sprachen wie HTML, CSS und JavaScript, die hauptsächlich in der Webentwicklung eingesetzt werden, zeichnet sich Python durch seine Vielseitigkeit in verschiedenen Bereichen aus, einschließlich Softwareentwicklung, Datenwissenschaft und Back-End-Entwicklung. Dieser Kurs wird Sie durch die grundlegenden Konzepte von Python führen und Ihnen die Fähigkeiten vermitteln, Ihre eigenen Funktionen bis zum Ende des Programms zu erstellen.

In diesem Abschnitt werden Sie die Grundlagen von Python erkunden, sich mit Ihrem Arbeitsbereich vertraut machen,
einfache mathematische Operationen durchführen und Ihre Ergebnisse anzeigen.

In diesem Abschnitt erfahren Sie, wie Sie Elemente wie Zahlen und Text im
Computerspeicher speichern und sie mit Namen abrufen können. Außerdem erhalten Sie eine Einführung in die
Textmanipulation in Python.

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

In diesem Abschnitt werden Sie weiterhin über Datentypen lernen und entdecken,
wie Sie verschiedene Attribute in einer einzigen Variablen mit Listen, Tupeln und Dictionaries organisieren können.

In diesem Abschnitt lernen Sie, wie man Schleifen in Python erstellt — eine wesentliche Fähigkeit
zum Durchlaufen von Listen, Tupeln und Dictionaries.

Um diesen Einführungskurs abzuschließen, werden Sie einige eingebaute
Funktionen erkunden und dann beginnen, Ihre eigenen zu entwickeln!

Herausforderung: Boolean Logik

Code-Anweisungen

Ausgabeanforderungen

Lösung

Awesome!

Herausforderung: Boolean Logik

Code-Anweisungen

Ausgabeanforderungen

Lösung