Summary  
This chapter covers the Boolean data type and demonstrates how comparison operators (==, !=, >, <, >=, <=) produce True or False values to evaluate conditions and drive decision-making in code.

General domain of usage  
Grocery store inventory management

In this chapter, we'll dive into the `Boolean` data type. Booleans are simple yet powerful, they allow us to handle `True` or `False` values, enabling our programs to **react to different situations** effectively. In the context of managing a grocery store, Booleans can help us determine whether certain conditions are met, such as whether an item is in stock or if a sale is active.

Watch as Alex uses `Boolean` data types to compare prices and names:


## Understanding Boolean Data Types

A **boolean** data type has only two possible values: `True` and `False`. These values are **often the result of comparison operations** and are fundamental in controlling the flow of our programs. By understanding booleans, you'll be able to write code that can **make decisions based on various conditions**.

The following operations are common **comparison operators that result in boolean values**:


- **Equal to**: `==`;
- **Not equal to**: `!=`;
- **Greater than**: `>`;
- **Less than**: `<`;
- **Greater than** or **equal to**: `>=`;
- **Less than** or **equal to**: `<=`.

### Example Application

Let's check if an item (`milk`) is **low in stock** by comparing its quantity to a predefined threshold for low stock:


# Define the quantity of the item and the low stock threshold
milk_quantity = 12
low_stock_threshold = 10

# Check if the item quantity is below the low stock threshold
low_stock = milk_quantity <= low_stock_threshold

# Print the result
print("Is the item low in stock?", low_stock)

Now it's your turn to practice using **booleans**. In this challenge, you will check if the total cost of a purchase is eligible for a discount.

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 TestDiscountEligibility(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)  # Replace multiple spaces/newlines with single space
        text = re.sub(r'\s*([,:?])\s*', r'\1 ', text)  # Normalize punctuation spacing
        return text.strip()

    def test_total_cost_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'total_cost') and user_code.total_cost == 25.00,
            "total_cost is defined correctly with value 25.00",
            f"Expected total_cost to be 25.00, got {getattr(user_code, 'total_cost', None)}"
        )

    def test_discount_eligibility_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'discountEligible') and user_code.discountEligible is True,
            "discountEligible is correctly True when total_cost >= 20.00",
            f"Expected discountEligible to be True, got {getattr(user_code, 'discountEligible', None)}"
        )

    def test_discount_comparison_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'>=', source) is not None,
            ">= operator used to compare total_cost to 20.00",
            "Expected usage of >= operator to compare total_cost and 20.00"
        )

    def test_print_output_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("Is the purchase eligible for a discount? True")
        _dynamic_test(
            self,
            expected in output,
            "Print output is correct and formatted as required",
            f"Expected print output to match: '{expected}', but got: '{output}'"
        )


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


test_main.py

Gain a solid foundation in Python for data analysis. Learn to work with variables, data types, strings, conditional statements, loops, core data structures, and functions using examples relevant to analytical tasks.

Booleans

Understanding Boolean Data Types

Example Application

Output Requirements

Рішення