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.

We've previously come across float and integer types, so now we can tell whether a value is a __float__ or an __integer__. Can you guess what the result of the math operation `6/1.5` might be? It's easy to calculate that it equals `4`, but what type does `4` belong to? It might seem like an integer, but it's actually a float. To confirm its type, you can use the `type()` function.

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

import unittest
from contextlib import redirect_stdout
import io
import importlib


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

    def test_number1_is_float(self):
        self._testMethodName = 'number1 is of type float'
        import user_code
        self.assertTrue(hasattr(user_code, 'number1'), "Expected number1 to be defined.")
        self.assertIsInstance(user_code.number1, float, f"Expected number1 to be a float, but got {type(user_code.number1).__name__}.")

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

    def test_number2_is_int(self):
        self._testMethodName = 'number2 is of type int'
        import user_code
        self.assertTrue(hasattr(user_code, 'number2'), "Expected number2 to be defined.")
        self.assertIsInstance(user_code.number2, int, f"Expected number2 to be a int, but got {type(user_code.number2).__name__}.")

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

    def test_type_number2_printed(self):
        self._testMethodName = "The type of number2 is <class 'int'> is printed"
        output = self._runcode_output()
        self.assertIn("is <class 'int'>", output, "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
if __name__ == '__main__':
    unittest.main()

test_main.py

Verkrijg een grondig begrip van de kerngegevenstypen van Python en leer hoe u hier effectief mee kunt werken. Ontdek getallen, booleans en strings aan de hand van praktische oefeningen en voorbeelden. Bouw vertrouwen op in het uitvoeren van basisbewerkingen en ontwikkel de fundamentele vaardigheden die nodig zijn om schone en efficiënte Python-code te schrijven.

Ontdek de basisprincipes van numerieke gegevenstypen in Python en leer werken met gehele getallen en drijvende-kommagetallen. Beheers elementaire rekenkundige bewerkingen, verken het concept van onveranderlijkheid en doe praktische ervaring op met de ingebouwde functies en hulpmiddelen van Python om getallen efficiënt te verwerken in realistische situaties.

Verkrijg een duidelijk begrip van het Booleaanse gegevenstype, een gespecialiseerd subtype van numerieke data dat waarheidswaarden weergeeft. Hoewel het in het begin uitdagend kan lijken, is het beheersen van Booleans essentieel voor het schrijven van logische en efficiënte programma's. Deze sectie helpt u om Booleaanse logica met vertrouwen toe te passen in praktische programmeersituaties.

Strings stellen u in staat om met tekst te werken in Python, van het weergeven van berichten tot het verwerken van gebruikersinvoer. U onderzoekt hoe u strings effectief kunt aanmaken, wijzigen en manipuleren. Inzicht in strings is essentieel voor het schrijven van interactieve programma's en het duidelijk overbrengen van informatie via uw code.

Leer hoe u datatypen effectief beheert om nauwkeurigheid en consistentie in uw programma's te waarborgen. Waarden omzetten naar het juiste type, tekst opschonen vóór vergelijking en numerieke bewerkingen scheiden van tekstformatering. U ontdekt ook hoe u ontbrekende gegevens doelbewust beheert en menselijk leesbare tekst anders behandelt dan ruwe invoer, wat resulteert in betrouwbare, consistente en goed leesbare uitkomsten.

Hoe Een Type Te Definiëren

Oplossing

Hoe Een Type Te Definiëren

Oplossing