Pronto para colocar tudo o que você aprendeu em **prática**? Este desafio exigirá que você use os operadores `and`, `or` e `not`, bem como **operadores de comparação booleanos**, para gerenciar um cenário complexo em uma mercearia.

Vamos mergulhar!


import unittest
import importlib
import io
from io import StringIO
from contextlib import redirect_stdout
import user_code

class TestUserCode(unittest.TestCase):
    def test_overstockRisk_defined(self):
        self._testMethodName = 'overstockRisk is defined'
        import user_code
        self.assertTrue(hasattr(user_code, 'overstockRisk'), "Expected overstockRisk to be defined.")

    def test_overstockRisk_uses_and_operator(self):
        self._testMethodName = 'overstockRisk uses logical and operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        self.assertRegex(code, r'overstockRisk\\s*=\\s*.*\\band\\b.*', "Expected overstockRisk to be defined using 'and' operator.")

    def test_overstockRisk_correct(self):
        self._testMethodName = 'overstockRisk has correct value'
        import user_code
        expected = user_code.seasonal and user_code.current_stock > user_code.high_stock_threshold
        self.assertEqual(user_code.overstockRisk, expected, f"Expected overstockRisk to be {{expected}}, but got {{user_code.overstockRisk}}.")

    def test_discountEligible_defined(self):
        self._testMethodName = 'discountEligible is defined'
        import user_code
        self.assertTrue(hasattr(user_code, 'discountEligible'), "Expected discountEligible to be defined.")

    def test_discountEligible_uses_not_and_operator(self):
        self._testMethodName = 'discountEligible uses logical not and operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        # Check for 'not selling_well and not on_sale'
        self.assertRegex(code, r'discountEligible\\s*=\\s*\\bnot\\b.*\\s*selling_well\\s*.*and\\s*\\bnot\\b.*\\s*on_sale', "Expected discountEligible to be defined using 'not selling_well and not on_sale'.")

    def test_discountEligible_correct(self):
        self._testMethodName = 'discountEligible has correct value'
        import user_code
        expected = (not user_code.selling_well) and (not user_code.on_sale)
        self.assertEqual(user_code.discountEligible, expected, f"Expected discountEligible to be {{expected}}, but got {{user_code.discountEligible}}.")

    def test_makeDiscount_defined(self):
        self._testMethodName = 'makeDiscount is defined'
        import user_code
        self.assertTrue(hasattr(user_code, 'makeDiscount'), "Expected makeDiscount to be defined.")

    def test_makeDiscount_uses_or_operator(self):
        self._testMethodName = 'makeDiscount uses logical or operator'
        with open('user_code.py', 'r') as f:
            code = f.read()
        self.assertRegex(code, r'makeDiscount\\s*=\\s*.*\\bor\\b.*', "Expected makeDiscount to be defined using 'or' operator.")

    def test_makeDiscount_correct(self):
        self._testMethodName = 'makeDiscount has correct value'
        import user_code
        expected = user_code.overstockRisk or user_code.discountEligible
        self.assertEqual(user_code.makeDiscount, expected, f"Expected makeDiscount to be {{expected}}, but got {{user_code.makeDiscount}}.")

    def test_print_output_correct(self):
        self._testMethodName = 'Printed output is correct'
        f = StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip()
        expected_output = f"Should the item be discounted? {user_code.makeDiscount}"
        self.assertEqual(output, expected_output, f"Expected print output to be '{{expected_output}}', but got '{{output}}'.")

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

test_main.py

Python é uma linguagem de programação de alto nível, interpretada e de propósito geral. Diferente de linguagens como HTML, CSS e JavaScript, que são principalmente utilizadas no desenvolvimento web, o Python se destaca pela versatilidade em múltiplos domínios, incluindo desenvolvimento de software, ciência de dados e desenvolvimento back-end. Este curso irá guiá-lo através dos conceitos fundamentais do Python, equipando-o com as habilidades para criar suas próprias funções ao final do programa.

Nesta seção, você explorará os fundamentos do Python, se familiarizará
com seu ambiente de trabalho, realizará operações matemáticas simples e exibirá suas descobertas.

Nesta seção, você descobrirá como salvar itens como números e texto
na memória do computador e recuperá-los pelo nome. Além disso, você terá uma introdução à manipulação de texto
em Python.

Nesta seção, você explorará o tipo de dado booleano e aprenderá como ele é usado
para desenvolver programas que reagem a certas condições.

Nesta seção, você continuará aprendendo sobre tipos de dados e descobrirá
como organizar vários atributos em uma única variável usando listas, tuplas e dicionários.

Nesta seção, você aprenderá a criar loops em Python — uma habilidade essencial
para iterar através de listas, tuplas e dicionários.

Para concluir este curso introdutório, você explorará algumas funções
embutidas e então começará a desenvolver as suas próprias!

Desafio: Lógica Booleana

Instruções de Código

Requisitos de Saída

Solução