**Herzlichen Glückwunsch** zum Erreichen dieses Abschnitts im Kurs! In dieser Abschlussaufgabe verwalten Sie **verderbliche Produkte** in einem Lebensmittelgeschäft und bestimmen Rabatte basierend auf dem Ablaufdatum und dem Lagerbestand der Produkte. Ziel ist es, Abfall zu minimieren und gleichzeitig den Umsatz durch gezielte Rabattaktionen zu maximieren.

Zeigen Sie, wie gut Sie Geschäftsregeln in Python-Code umsetzen können!

## Szenario

Als Manager in einem Lebensmittelgeschäft sind Sie für die **Umsetzung einer Rabattstrategie** für verderbliche Produkte verantwortlich, basierend auf deren Ablaufdatum und Lagerbestand.

Die Rabattstrategie lautet wie folgt:

- **30 %** Rabatt, wenn das Produkt **in 3 Tagen oder weniger abläuft** und der Lagerbestand **über** `50` Einheiten liegt;
- **20 %** Rabatt, wenn das Produkt **in 4 bis 6 Tagen abläuft** und der Lagerbestand **über** `50` Einheiten liegt;
- **10 %** Rabatt, wenn das Produkt **in 7 Tagen oder mehr abläuft** oder der Lagerbestand `50` Einheiten oder **weniger** beträgt;
- **Kein Rabatt**, wenn das Produkt nicht "Perishable" ist.


import unittest
import io
import re
from contextlib import redirect_stdout


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(path):
    try:
        with open(path, 'r') as file:
            source = file.read()
        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 TestPerishableDiscounts(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 run_code_with_inputs(self, product_type, days, stock):
        with open('user_code.py', 'r') as f:
            code = f.read()

        # ÐÐ¾Ð´ÑÑÐ°Ð½Ð¾Ð²ÐºÐ° Ð²ÑÐ¾Ð´Ð½ÑÑ Ð·Ð½Ð°ÑÐµÐ½Ð¸Ð¹
        code = re.sub(r'days_until_expiration\s*=\s*\d+', f'days_until_expiration = {days}', code)
        code = re.sub(r'stock_level\s*=\s*\d+', f'stock_level = {stock}', code)
        code = re.sub(r'product_type\s*=\s*["\\\'].*?["\\\']', f'product_type = "{product_type}"', code)

        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, {})
        return self.normalize_text(f.getvalue())

    def test_30_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 2, 51)
        expected = self.normalize_text("30% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "30% discount applied for <=3 days and stock > 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_20_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 5, 55)
        expected = self.normalize_text("20% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "20% discount applied for 4 to 6 days and stock > 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_10_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 7, 50)
        expected = self.normalize_text("10% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "10% discount applied for >6 days and stock <= 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_non_perishable_no_discount(self):
        output = self.run_code_with_inputs("Non-Perishable", 2, 100)
        expected = self.normalize_text("No discount available for non-perishable items.")
        _dynamic_test(
            self,
            expected in output,
            "No discount applied for non-perishable item",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_nested_conditionals_used(self):
        source = strip_comments_from_source("user_code.py")
        has_nested_if = re.search(r'if', source)
        _dynamic_test(
            self,
            has_nested_if is not None,
            "Nested if-statements are used inside main product_type check",
            "Expected nested 'if' inside 'if product_type == \\\"Perishable\\\"'"
        )


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: Product-Management-Capstone

Szenario

Lösung