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

Verkrijg een grondig begrip van de kern-datatypen van Python en leer hoe u hier effectief mee kunt werken. Ontdek getallen, booleans en strings aan de hand van praktische oefeningen en voorbeelden. Bouw vertrouwen op in het uitvoeren van basisbewerkingen en ontwikkel de fundamentele vaardigheden die nodig zijn om duidelijke en efficiënte Python-code te schrijven.

Ontdek de basisprincipes van numerieke gegevenstypen in Python en leer werken met gehele getallen en drijvende-kommagetallen. Beheers elementaire rekenkundige bewerkingen, verken het concept van onveranderlijkheid en doe praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python om getallen efficiënt te verwerken in realistische situaties.

Verkrijg een duidelijk begrip van het Booleaanse gegevenstype, een gespecialiseerd subtype van numerieke gegevens dat waarheidswaarden weergeeft. Hoewel het in het begin uitdagend kan lijken, is het beheersen van Booleans essentieel voor het schrijven van logische en efficiënte programma's. Deze sectie helpt u om Booleaanse logica met vertrouwen toe te passen in praktische programmeersituaties.

Strings stellen je in staat om met tekst te werken in Python, van het weergeven van berichten tot het verwerken van gebruikersinvoer. Je onderzoekt hoe je strings effectief kunt aanmaken, wijzigen en manipuleren. Inzicht in strings is essentieel voor het schrijven van interactieve programma's en het duidelijk overbrengen van informatie via je code.

Leer hoe u datatypen effectief beheert om nauwkeurigheid en consistentie in uw programma's te waarborgen. Waarden omzetten naar het juiste type, tekst opschonen vóór vergelijking en numerieke bewerkingen scheiden van tekstformatering. U ontdekt ook hoe u ontbrekende gegevens doelbewust beheert en mensleesbare tekst anders behandelt dan ruwe invoer, wat resulteert in betrouwbare, consistente en gemakkelijk leesbare resultaten.

Uitdaging: Tijdsberekening

Oplossing

Awesome!

Uitdaging: Tijdsberekening

Oplossing