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

Trekker det høyre tallet fra det venstre

Dividerer tall (returnerer alltid et flyttall)

Opphøyer tallet til venstre i potensen til tallet til høyre

Viser fortegnet til et tall (positiv eller negativ)


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

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")
        # 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):
        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
        all_ok = declared and correct_type and correct_value
        _dynamic_test(
            self,
            all_ok,
            "Total minutes calculated correctly",
            "Total minutes calculated incorrectly"
        )

    def test_shortfall(self):
        declared = hasattr(self.m, "shortfall")
        correct_type = isinstance(getattr(self.m, "shortfall", None), int)
        correct_value = declared and self.m.shortfall == self.expected_shortfall
        all_ok = declared and correct_type and correct_value
        _dynamic_test(
            self,
            all_ok,
            "Shortfall calculated correctly",
            "Shortfall calculated incorrectly"
        )

    def test_completed_calls(self):
        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
        all_ok = declared and correct_type and correct_value
        _dynamic_test(
            self,
            all_ok,
            "Completed calls calculated correctly",
            "Completed calls calculated incorrectly"
        )

    def test_unused_time(self):
        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
        all_ok = declared and correct_type and correct_value
        _dynamic_test(
            self,
            all_ok,
            "Unused time calculated correctly",
            "Unused time calculated incorrectly"
        )

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

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

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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, strenger, samt hvordan du trygt kan konvertere og sammenligne verdier på tvers av typer. Bygg selvtillit i å utføre aritmetiske, logiske og strengoperasjoner, og utvikle de grunnleggende ferdighetene som trengs for å skrive ren og pålitelig Python-kode.

Utforsk det grunnleggende om numeriske typer i Python, fra heltall og flyttall til aritmetikk og operatorprioritet. Øv på heltallsdivisjon, modulo og funksjoner fra math-modulen gjennom praktiske eksempler på tids- og budsjettberegninger.

Få en grundig forståelse av datatypen boolsk og hvordan sammenligningsoperatorer vurderer likhet, identitet og sannhetsverdier. Bruk logiske operatorer for å bygge tydelige og presise betingelser for programmering i virkelige situasjoner.



Få praktisk erfaring med strenger i Python, fra opprettelse og indeksering til oppdeling, søk og formatering av tekst. Forstå hvorfor strenger er uforanderlige og hvordan nye strenger kan bygges effektivt for interaktive programmer.



Utforsk hvordan du konverterer mellom Pythons grunnleggende datatyper, sammenligner strenger pålitelig ved å normalisere store og små bokstaver samt mellomrom, og håndterer manglende verdier med None. Lær når du bør bruke bytes og bytearray for rå binærdata i praktiske programmer.



Utfordring: Tidsberegning

Utfordring: Tidsberegning

Løsning