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 matematikoperationen `6/1.5` blir? 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 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 tal effektivt i verkliga situationer.

Få en tydlig förståelse för datatypen Boolean, en specialiserad undergrupp av numerisk data som representerar sanningsvärden. Även om det kan verka utmanande till en början är det avgörande att behärska Booleans för att skriva logiska och effektiva program. Detta avsnitt hjälper dig att säkert tillämpa Boolean-logik i verkliga programmeringsscenarier.

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 hanterar 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 att 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 kommer även att upptäcka hur man hanterar saknade data medvetet och behandlar läsbar text annorlunda än rå indata, för att uppnå tillförlitliga, konsekventa och lättlästa resultat.

Hur Man Definierar en Typ

Lösning