Summary  
This chapter explains how to perform basic arithmetic operations in Python, covering binary operators (addition, subtraction, multiplication, division, floor division, modulus, exponentiation) and unary plus/minus.

General domain of usage  
Scientific computing

import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.src = f.read()

        # Expected values
        cls.expected_total = 8 * 9           # 72
        cls.expected_shortfall = 72 - 60     # 12
        cls.expected_completed = 60 // 9     # 6
        cls.expected_unused = 60 % 9         # 6

    def test_total_minutes(self):
        """Validate total_minutes"""
        declared = hasattr(self.m, "total_minutes")
        correct_type = isinstance(getattr(self.m, "total_minutes", None), int)
        correct_value = declared and self.m.total_minutes == self.expected_total
        uses_multiplication = re.search(
            r"total_minutes\s*=\s*.*\*.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_multiplication
        _dynamic_test(
            self,
            all_ok,
            "Total minutes calculated correctly",
            "Total minutes calculated incorrectly"
        )

    def test_shortfall(self):
        """Validate shortfall"""
        declared = hasattr(self.m, "shortfall")
        correct_type = isinstance(getattr(self.m, "shortfall", None), int)
        correct_value = declared and self.m.shortfall == self.expected_shortfall
        uses_subtraction = re.search(
            r"shortfall\s*=\s*.*-.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_subtraction
        _dynamic_test(
            self,
            all_ok,
            "Shortfall calculated correctly",
            "Shortfall calculated incorrectly"
        )

    def test_completed_calls(self):
        """Validate completed_calls"""
        declared = hasattr(self.m, "completed_calls")
        correct_type = isinstance(getattr(self.m, "completed_calls", None), int)
        correct_value = declared and self.m.completed_calls == self.expected_completed
        uses_floor_division = re.search(
            r"completed_calls\s*=\s*.*//.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_floor_division
        _dynamic_test(
            self,
            all_ok,
            "Completed calls calculated correctly",
            "Completed calls calculated incorrectly"
        )

    def test_unused_time(self):
        """Validate unused_time"""
        declared = hasattr(self.m, "unused_time")
        correct_type = isinstance(getattr(self.m, "unused_time", None), int)
        correct_value = declared and self.m.unused_time == self.expected_unused
        uses_modulo = re.search(
            r"unused_time\s*=\s*.*%.*", self.src
        ) is not None

        all_ok = declared and correct_type and correct_value and uses_modulo
        _dynamic_test(
            self,
            all_ok,
            "Unused time calculated correctly",
            "Unused time calculated incorrectly"
        )

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

test_code.py

Acquérez une compréhension solide des principaux types de données de Python et apprenez à les manipuler efficacement. Explorez les nombres, les booléens et les chaînes de caractères à travers des exercices pratiques et des exemples concrets. Développez votre confiance dans l'exécution des opérations de base et acquérez les compétences fondamentales nécessaires pour écrire un code Python clair et efficace.

Découvrez les principes fondamentaux des types de données numériques en Python et apprenez à manipuler les entiers et les nombres à virgule flottante. Maîtrisez les opérations arithmétiques de base, explorez le concept d'immutabilité et acquérez une expérience pratique avec les fonctions et outils intégrés de Python pour gérer efficacement les nombres dans des situations réelles.

Comprendre clairement le type de données booléen, un sous-type spécialisé des données numériques représentant les valeurs de vérité. Bien qu'il puisse sembler difficile au début, la maîtrise des booléens est essentielle pour écrire des programmes logiques et efficaces. Cette section vous aidera à appliquer avec assurance la logique booléenne à des scénarios de programmation concrets.

Les chaînes de caractères permettent de travailler avec du texte en Python, qu'il s'agisse d'afficher des messages ou de traiter des saisies utilisateur. Vous découvrirez comment créer, modifier et manipuler efficacement des chaînes de caractères. La compréhension des chaînes de caractères est essentielle pour écrire des programmes interactifs et transmettre clairement des informations à travers votre code.

Apprenez à gérer efficacement les types de données afin d’assurer l’exactitude et la cohérence de vos programmes. Convertissez les valeurs au type approprié, nettoyez le texte avant toute comparaison et séparez les opérations numériques du formatage du texte. Découvrez également comment gérer de manière délibérée les données manquantes et traiter différemment le texte lisible par l’humain des entrées brutes, pour obtenir des résultats fiables, cohérents et faciles à lire.

Défi : Calcul du Temps

Solution

Awesome!

Défi : Calcul du Temps

Solution