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 solid forståelse av Pythons grunnleggende datatyper og lær hvordan du arbeider effektivt med dem. Utforsk tall, boolske verdier og strenger gjennom praktiske øvelser og eksempler. Bygg selvtillit i å utføre grunnleggende operasjoner og utvikle de nødvendige ferdighetene for å skrive ryddig og effektiv Python-kode.

Oppdag det grunnleggende om numeriske datatyper i Python og lær hvordan du arbeider med heltall og flyttall. Få oversikt over grunnleggende aritmetiske operasjoner, utforsk begrepet uforanderlighet, og få praktisk erfaring med Pythons innebygde funksjoner og verktøy for effektiv håndtering av tall i virkelige situasjoner.

Få en tydelig forståelse av den boolske datatypen, en spesialisert undergruppe av numeriske data som representerer sannhetsverdier. Selv om det kan virke utfordrende i starten, er det avgjørende å beherske boolske verdier for å skrive logiske og effektive programmer. Denne delen hjelper deg å anvende boolsk logikk trygt i programmeringsscenarier fra virkeligheten.

Strenger lar deg arbeide med tekst i Python, fra å vise meldinger til å behandle brukerinput. Du vil utforske hvordan du kan opprette, endre og manipulere strenger på en effektiv måte. Forståelse av strenger er avgjørende for å skrive interaktive programmer og formidle informasjon tydelig gjennom koden din.

Lær hvordan du håndterer datatyper effektivt for å sikre nøyaktighet og konsistens i programmene dine. Konverter verdier til riktig type, rens tekst før sammenligning, og skill mellom numeriske operasjoner og tekstformatering. Du vil også oppdage hvordan du bevisst håndterer manglende data og behandler lesbar tekst annerledes enn rå input, for å oppnå pålitelige, konsistente og lettleste resultater.

Utfordring: Tidsberegning

Løsning

Utfordring: Tidsberegning

Løsning