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.

Wir haben bereits die Typen Float und Integer kennengelernt, sodass wir nun erkennen können, ob ein Wert ein __Float__ oder ein __Integer__ ist. Kannst du erraten, welches Ergebnis die mathematische Operation `6/1.5` liefert? Es ist leicht auszurechnen, dass das Ergebnis `4` ist, aber zu welchem Typ gehört `4`? Es könnte wie ein Integer erscheinen, aber tatsächlich ist es ein Float. Um den Typ zu bestätigen, kann die Funktion `type()` verwendet werden.

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

Erwerben Sie ein fundiertes Verständnis der grundlegenden Datentypen in Python und lernen Sie, wie Sie effektiv mit ihnen arbeiten. Erkunden Sie Zahlen, Booleans, Strings sowie die sichere Umwandlung und den Vergleich von Werten zwischen verschiedenen Typen. Stärken Sie Ihr Vertrauen im Umgang mit arithmetischen, logischen und String-Operationen und entwickeln Sie die grundlegenden Fähigkeiten, um sauberen und zuverlässigen Python-Code zu schreiben.

Erkunden Sie die Grundlagen der numerischen Datentypen in Python, einschließlich Ganzzahlen und Fließkommazahlen, sowie Arithmetik und Operatorrangfolge. Üben Sie Ganzzahldivision, Modulo und Funktionen des math-Moduls anhand praxisnaher Zeit- und Budgetberechnungen.

Erwerben Sie ein fundiertes Verständnis des Booleschen Datentyps und wie Vergleichsoperatoren Gleichheit, Identität und Wahrheitswerte auswerten. Anwenden von logischen Operatoren zur Erstellung klarer, präziser Bedingungen für praxisnahe Programmieraufgaben.



Praktische Erfahrungen mit Python-Strings, von der Erstellung und Indizierung bis hin zum Slicing, Suchen und Formatieren von Text. Verständnis der Unveränderlichkeit von Strings und effiziente Erstellung neuer Strings für interaktive Programme.



Erfahren Sie, wie Sie zwischen den grundlegenden Datentypen von Python konvertieren, Zeichenfolgen durch Normalisierung von Groß-/Kleinschreibung und Leerzeichen zuverlässig vergleichen und fehlende Werte mit None behandeln. Verstehen Sie, wann bytes und bytearray für rohe Binärdaten in praxisnahen Programmen verwendet werden.



Herausforderung: Wie Man Einen Typ Definiert

Herausforderung: Wie Man Einen Typ Definiert

Lösung