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.

Olemme aiemmin tutustuneet float- ja integer-tyyppeihin, joten nyt voimme tunnistaa, onko arvo __float__ vai __integer__. Osaatko arvata, mikä on laskutoimituksen `6/1.5` tulos? On helppo laskea, että se on `4`, mutta mihin tyyppiin `4` kuuluu? Se saattaa vaikuttaa kokonaisluvulta, mutta se on itse asiassa float. Voit varmistaa tyypin käyttämällä `type()`-funktiota.

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

Hanki vankka ymmärrys Pythonin keskeisistä tietotyypeistä ja opi työskentelemään niiden kanssa tehokkaasti. Tutustu numeroihin, totuusarvoihin, merkkijonoihin sekä siihen, miten arvoja muunnetaan ja verrataan turvallisesti eri tyyppien välillä. Kehitä varmuutta aritmeettisten, loogisten ja merkkijono-operaatioiden suorittamisessa sekä perusosaamista, jota tarvitaan selkeän ja luotettavan Python-koodin kirjoittamiseen.

Tutustu Pythonin numeeristen tietotyyppien perusteisiin, kuten kokonaislukuihin ja liukulukuihin, sekä aritmetiikkaan ja operaattorien etusijajärjestykseen. Harjoittele lattiakertolaskua, jakojäännöstä ja math-moduulin funktioita käytännön ajan- ja budjettilaskelmien avulla.

Perusteellinen ymmärrys Boolean-tietotyypistä sekä siitä, miten vertailuoperaattorit arvioivat yhtäsuuruutta, identiteettiä ja totuusarvoja. Loogisten operaattoreiden hyödyntäminen selkeiden ja tarkkojen ehtojen rakentamiseen ohjelmointitilanteissa.

Saat käytännön kokemusta Python-merkkijonoista, niiden luomisesta ja indeksoinnista aina viipalointiin, hakemiseen ja tekstin muotoiluun asti. Ymmärrä, miksi merkkijonot ovat muuttumattomia ja kuinka rakentaa uusia merkkijonoja tehokkaasti vuorovaikutteisia ohjelmia varten.



Opi muuntamaan Pythonin ydintietotyyppejä, vertailemaan merkkijonoja luotettavasti normalisoimalla kirjainkoko ja välilyönnit sekä käsittelemään puuttuvia arvoja None-arvon avulla.
Ymmärrä, milloin käyttää bytes- ja bytearray-tyyppejä raakadatan käsittelyyn käytännön ohjelmissa.



Haaste: Kuinka Määritellä Tietotyyppi

Ratkaisu