Summary  
This chapter explains how to use Python’s built-in type() function (via printing) to inspect data types and illustrates how arithmetic operations—especially division—affect numeric types, with division always yielding a float and mixed-type operations promoting to float.  

General domain of usage  
Numeric computations

Watch this video to see how Python determines the type of a value during calculations, and how you can use the type() function to check the type of any variable. You'll learn why certain operations, like division, result in a float even when the answer looks like a whole number, and how to confidently identify and work with different number types in your code.

Vi har tidigare stött på float- och integer-typer, så nu kan vi avgöra om ett värde är en __float__ eller en __integer__. Kan du gissa vad resultatet av den matematiska operationen `6/1.5` kan bli? Det är enkelt att räkna ut att det är `4`, men vilken typ tillhör `4`? Det kan verka som en integer, men det är faktiskt en float. För att bekräfta typen kan du använda funktionen `type()`.

variable = 6/1.5
print(variable)
print(type(variable))


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
from contextlib import redirect_stdout
import io
import importlib

class TestUserCode(unittest.TestCase):
    def test_number1_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'number1'),
            "number1 is declared correctly.",
            "Expected number1 to be defined."
        )

    def test_number1_is_float(self):
        import user_code
        has_var = hasattr(user_code, 'number1')
        _dynamic_test(
            self,
            has_var,
            "number1 is present for type check.",
            "Expected number1 to be defined."
        )
        if has_var:
            _dynamic_test(
                self,
                isinstance(user_code.number1, float),
                "number1 is of type float.",
                f"Expected number1 to be a float, but got {type(user_code.number1).__name__}."
            )

    def test_number2_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'number2'),
            "number2 is declared correctly.",
            "Expected number2 to be defined."
        )

    def test_number2_is_int(self):
        import user_code
        has_var = hasattr(user_code, 'number2')
        _dynamic_test(
            self,
            has_var,
            "number2 is present for type check.",
            "Expected number2 to be defined."
        )
        if has_var:
            _dynamic_test(
                self,
                isinstance(user_code.number2, int),
                "number2 is of type int.",
                f"Expected number2 to be a int, but got {type(user_code.number2).__name__}."
            )

    def test_type_number1_printed(self):
        output = self._runcode_output()
        _dynamic_test(
            self,
            "number1 is <class 'float'>" in output,
            "The type of number1 is <class 'float'> is printed.",
            "Expected the output to contain 'The type of number1 is <class \\'float\\'>'"
        )

    def test_type_number2_printed(self):
        output = self._runcode_output()
        _dynamic_test(
            self,
            "is <class 'int'>" in output,
            "The type of number2 is <class 'int'> is printed.",
            "Expected the output to contain 'The type of number2 is <class \\'float\\'>'"
        )

    def _runcode_output(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        s = f.getvalue().strip()
        return s

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_main.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, strängar samt hur du säkert konverterar och jämför värden mellan olika typer. Bygg upp förtroende i att utföra aritmetiska, logiska och strängoperationer och utveckla de grundläggande färdigheter som krävs för att skriva ren och tillförlitlig Python-kod.

Utforska grunderna i Pythons numeriska typer, från heltal och flyttal till aritmetik och operatorprioritet. Öva på heltalsdivision, modulo och funktioner i math-modulen genom verklighetsbaserade tids- och budgetberäkningar.

Få en gedigen förståelse för datatypen Boolean och hur jämförelseoperatorer utvärderar likhet, identitet och sanningsvärden. Använd logiska operatorer för att skapa tydliga och korrekta villkor för verkliga programmeringsscenarier.



Få praktisk erfarenhet av Python-strängar, från att skapa och indexera dem till att dela upp, söka och formatera text. Förstå varför strängar är oföränderliga och hur nya strängar kan byggas effektivt för interaktiva program.



Upptäck hur du konverterar mellan Pythons grundläggande datatyper, jämför strängar på ett tillförlitligt sätt genom att normalisera skiftläge och blanksteg, samt hanterar saknade värden med None. Lär dig när du ska använda bytes och bytearray för rå binärdata i verkliga program.



Utmaning: Hur man definierar en typ

Utmaning: Hur man definierar en typ

Lösning