Prêt à mettre en **pratique** tout ce que vous avez appris ? Ce défi vous demandera d'utiliser les **opérateurs** `and`, `or` et `not` ainsi que les **opérateurs de comparaison booléens** pour gérer un scénario complexe pour un magasin d'alimentation.

Plongeons-nous dedans !


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

class TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_overstockRisk_defined(self):
        self._testMethodName = 'overstockRisk is defined'
        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'
        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'
        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()
        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'
        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'
        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'
        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 = self.normalize_text(f.getvalue().strip())
        expected_output = self.normalize_text(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 est un langage de programmation interprété, de haut niveau et à usage général. Distingué des langages tels que HTML, CSS et JavaScript, principalement utilisés dans le développement web, Python se distingue par sa polyvalence dans plusieurs domaines, y compris le développement de logiciels, la science des données et le développement back-end. Ce cours vous guidera à travers les concepts fondamentaux de Python, vous dotant des compétences nécessaires pour créer vos propres fonctions à la fin du programme.

Dans cette section, vous explorerez les fondamentaux de Python, vous vous familiariserez
avec votre espace de travail, effectuerez des opérations mathématiques simples et afficherez vos résultats.

Dans cette section, vous découvrirez comment enregistrer des éléments tels que des nombres et du texte
dans la mémoire de l'ordinateur et les récupérer par leur nom. De plus, vous aurez une introduction à la manipulation de texte
en Python.

Dans cette section, vous explorerez le type de données booléen et apprendrez comment il est utilisé
pour développer des programmes qui réagissent à certaines conditions.

Dans cette section, vous continuerez à apprendre sur les types de données et découvrirez
comment organiser divers attributs dans une seule variable en utilisant des lists, des tuples et des dictionnaires.

Dans cette section, vous apprendrez à créer des boucles en Python — une compétence essentielle
pour parcourir les listes, les tuples et les dictionnaires.

Pour conclure ce cours d'introduction, vous explorerez certaines fonctions intégrées
puis commencerez à développer les vôtres !

Défi : Logique Booléenne

Instructions de Code

Exigences de Sortie

Solution

Awesome!

Défi : Logique Booléenne

Instructions de Code

Exigences de Sortie

Solution