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

Basándonos en tu **comprensión de los booleanos**, ahora exploraremos cómo **combinar múltiples condiciones** en Python. Esta habilidad permite que tus programas tomen **decisiones más matizadas** al verificar varios criterios simultáneamente.
Observa cómo Alex combina múltiples condiciones para tomar mejores decisiones durante las operaciones en la tienda de comestibles:

## Comprensión de condiciones combinadas

En Python, puedes **combinar condiciones utilizando operadores lógicos** como `and`, `or` y `not`. Estos operadores permiten crear condiciones compuestas que evalúan múltiples expresiones booleanas.

- `and`: devuelve `True` si ambas condiciones son `True`;
- `or`: devuelve `True` si al menos una condición es `True`;
- `not`: devuelve `True` si la condición es `False` (y viceversa).


### Aplicación de ejemplo

Combinemos condiciones para verificar si un artículo es un producto perecedero **Y** tiene un alto stock utilizando el operador `and`:

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)

Ahora, combinemos **condiciones** para verificar si un artículo es de temporada **O** si es un artículo festivo usando el operador `or`:


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) 

Finalmente, combinando condiciones para verificar si un artículo **NO** necesita cambio de precio utilizando el operador `not`:

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 es un lenguaje de programación de alto nivel, interpretado y de propósito general. A diferencia de lenguajes como HTML, CSS y JavaScript, que se utilizan principalmente en el desarrollo web, Python destaca por su versatilidad en múltiples dominios, incluyendo el desarrollo de software, la ciencia de datos y el desarrollo back-end. Este curso te guiará a través de los conceptos fundamentales de Python, proporcionándote las habilidades necesarias para crear tus propias funciones al finalizar el programa.

En esta sección, se explorarán los fundamentos de Python, se familiarizará con el entorno de trabajo, se realizarán operaciones matemáticas simples y se mostrarán los resultados.

En esta sección, descubrirá cómo almacenar elementos como números y texto
en la memoria de la computadora y recuperarlos por nombre. Además, obtendrá una introducción a la manipulación de texto
en Python.

En esta sección, explorará el tipo de dato booleano y aprenderá cómo se utiliza para desarrollar programas que reaccionan a ciertas condiciones.

En esta sección, continuará aprendiendo sobre los tipos de datos y descubrirá
cómo organizar varios atributos en una sola variable utilizando listas, tuplas y diccionarios.

En esta sección, aprenderás a crear bucles en Python, una habilidad esencial para iterar a través de listas, tuplas y diccionarios.

Para concluir este curso introductorio, explorarás algunas funciones integradas
y luego comenzarás a desarrollar las tuyas propias.

Combinando Condiciones

Comprensión de condiciones combinadas

Aplicación de ejemplo

Requisitos de salida

Solución