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

Få en gedigen förståelse för Pythons grundläggande datatyper och lär dig att arbeta effektivt med dem. Utforska tal, booleska värden och strängar genom praktiska övningar och exempel. Bygg upp självförtroende i att utföra grundläggande operationer och utveckla de grundläggande färdigheter som krävs för att skriva ren och effektiv Python-kod.

Upptäck grunderna i numeriska datatyper i Python och lär dig arbeta med heltal och flyttal. Behärska grundläggande aritmetiska operationer, utforska begreppet oföränderlighet och få praktisk erfarenhet av att använda Pythons inbyggda funktioner och verktyg för att hantera nummer effektivt i verkliga situationer.

Få en tydlig förståelse för datatypen bool, en specialiserad undergrupp av numeriska data som representerar sanningsvärden. Även om det kan verka utmanande till en början är det avgörande att behärska booleska värden för att skriva logiska och effektiva program. Detta avsnitt hjälper dig att tillämpa boolesk logik i verkliga programmeringssammanhang med självförtroende.

Strängar gör det möjligt att arbeta med text i Python, från att visa meddelanden till att bearbeta användarinmatning. Du kommer att utforska hur man skapar, modifierar och manipulerar strängar på ett effektivt sätt. Förståelse för strängar är avgörande för att skriva interaktiva program och för att tydligt kommunicera information genom din kod.

Lär dig hantera datatyper effektivt för att säkerställa noggrannhet och konsekvens i dina program. Konvertera värden till lämplig typ, rensa text före jämförelse och separera numeriska operationer från textformatering. Du får även veta hur man hanterar saknade data medvetet och behandlar läsbar text annorlunda än rå indata, vilket ger tillförlitliga, konsekventa och lättlästa resultat.

Utmaning: Tidsberäkning

Lösning

Utmaning: Tidsberäkning

Lösning