Summary  
This chapter explains how to form compound Boolean conditions in Python using the logical operators `and`, `or`, and `not` to evaluate multiple criteria in a single expression.

General domain of usage  
Grocery store inventory management

Aufbauend auf Ihrem **Verständnis von Booleans** werden wir nun untersuchen, wie man in Python **mehrere Bedingungen kombiniert**. Diese Fähigkeit ermöglicht es Ihren Programmen, **differenziertere Entscheidungen** zu treffen, indem mehrere Kriterien gleichzeitig überprüft werden.
Sehen Sie, wie Alex mehrere Bedingungen kombiniert, um bessere Entscheidungen bei den Abläufen im Supermarkt zu treffen:

## Verständnis kombinierter Bedingungen

In Python können Sie **Bedingungen mit logischen Operatoren** wie `and`, `or` und `not` kombinieren. Diese Operatoren ermöglichen es, zusammengesetzte Bedingungen zu erstellen, die mehrere boolesche Ausdrücke auswerten.

- `and`: ergibt `True`, wenn beide Bedingungen `True` sind;
- `or`: ergibt `True`, wenn mindestens eine Bedingung `True` ist;
- `not`: ergibt `True`, wenn die Bedingung `False` ist (und umgekehrt).


### Anwendungsbeispiel

Kombinieren wir Bedingungen, um zu prüfen, ob ein Artikel sowohl ein verderbliches Gut **UND** in großer Menge auf Lager ist, indem wir den Operator `and` verwenden:

is_perishable = True
item_quantity = 110
perishable_highStockRisk = 100

# Combine two or more conditions
consider_discount = is_perishable and (item_quantity >= perishable_highStockRisk)

# Print the result
print("Is the item perishable and high in stock?", consider_discount)

Nun werden **Bedingungen kombiniert**, um zu prüfen, ob ein Artikel entweder ein saisonaler Artikel **ODER** ein Feiertagsartikel ist, indem der Operator `or` verwendet wird:


seasonal_item = False
holiday_item = True

# Check if the item is seasonal or discounted
temporary_stock = seasonal_item or holiday_item

# Print the result
print("Is this a seasonal or holiday item?", temporary_stock) 

Abschließend werden **Bedingungen kombiniert**, um zu prüfen, ob ein Artikel **KEINE** Neubepreisung benötigt, indem der Operator `not` verwendet wird:

is_perishable = True

# Check if the item is NOT perishable
long_shelf_life = not is_perishable

# Print the result
print("Does the item need to be sold quickly?", long_shelf_life) 

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 TestPromotionEligibility(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_moving_product_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'movingProduct') and user_code.movingProduct is True,
            "movingProduct is correctly set to True",
            f"Expected movingProduct to be True, got {getattr(user_code, 'movingProduct', None)}"
        )

    def test_promotion_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'promotion') and user_code.promotion is False,
            "promotion is correctly set to False",
            f"Expected promotion to be False, got {getattr(user_code, 'promotion', 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("Is the item eligible for promotion? False")
        _dynamic_test(
            self,
            expected in output,
            "Print output matches expected format",
            f"Expected print output to be '{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, but none found"
        )

    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, but none found"
        )


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.

Kombinieren von Bedingungen

Verständnis kombinierter Bedingungen

Anwendungsbeispiel

Ausgabebedingungen

Lösung