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

Approfondendo la **comprensione dei booleani**, esploreremo ora come **combinare più condizioni** in Python. Questa competenza permette ai programmi di prendere decisioni ancora **più sofisticate** verificando più criteri contemporaneamente.
Guarda come Alex combina più condizioni per prendere decisioni migliori durante le operazioni al supermercato:

## Comprendere le condizioni combinate

In Python, è possibile **combinare condizioni utilizzando operatori logici** come `and`, `or` e `not`. Questi operatori consentono di creare condizioni composte che valutano più espressioni booleane.

- `and`: restituisce `True` se entrambe le condizioni sono `True`;
- `or`: restituisce `True` se almeno una condizione è `True`;
- `not`: restituisce `True` se la condizione è `False` (e viceversa).


### Applicazione di esempio

Combiniamo le condizioni per verificare se un articolo è sia un prodotto deperibile **E** ha una scorta elevata utilizzando l'operatore `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)

Ora, **combina le condizioni** per verificare se un articolo è un articolo stagionale **OPPURE** se è un articolo festivo utilizzando l'operatore `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) 

Infine, combinazione di condizioni per verificare se un articolo **NON** necessita di una nuova determinazione del prezzo utilizzando l'operatore `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 è un linguaggio di programmazione di alto livello, interpretato e di uso generale. A differenza di linguaggi come HTML, CSS e JavaScript, principalmente utilizzati nello sviluppo web, Python si distingue per la sua versatilità in molteplici ambiti, tra cui lo sviluppo software, la data science e lo sviluppo back-end. Questo corso ti guiderà attraverso i concetti fondamentali di Python, fornendoti le competenze necessarie per creare le tue funzioni al termine del programma.

In questa sezione, verranno esplorati i fondamenti di Python, familiarizzazione con l'ambiente di lavoro, esecuzione di semplici operazioni matematiche e visualizzazione dei risultati.

In questa sezione scoprirai come salvare elementi come numeri e testo nella memoria del computer e recuperarli tramite un nome. Inoltre, riceverai un'introduzione alla manipolazione del testo in Python.

In questa sezione, esplorerai il tipo di dato booleano e apprenderai come viene utilizzato per sviluppare programmi che reagiscono a determinate condizioni.

In questa sezione continuerai ad approfondire i tipi di dati e scoprirai
come organizzare vari attributi in una singola variabile utilizzando liste, tuple e dizionari.

In questa sezione, apprenderai come creare cicli in Python — una competenza essenziale per iterare su liste, tuple e dizionari.

Per concludere questo corso introduttivo, esplorerai alcune funzioni integrate
e poi inizierai a sviluppare le tue.

Combinazione di Condizioni

Comprendere le condizioni combinate

Applicazione di esempio

Requisiti di output

Soluzione