Summary  
It demonstrates how to determine a variable’s data type using the `type()` function, showing that arithmetic operations can produce floats even when the result appears to be an integer.

General domain of usage  
numeric computation

We hebben eerder float- en integer-typen besproken, dus nu kunnen we bepalen of een waarde een __float__ of een __integer__ is. Kun je raden wat het resultaat is van de wiskundige bewerking `6/1.5`? Het is eenvoudig te berekenen dat dit `4` is, maar tot welk type behoort `4`? Het lijkt misschien een integer, maar het is eigenlijk een float. Om het type te bevestigen, kun je de functie `type()` gebruiken.

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 kern-datatypen 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 duidelijke 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 gegevens 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 je in staat om met tekst te werken in Python, van het weergeven van berichten tot het verwerken van gebruikersinvoer. Je onderzoekt hoe je 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 je 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 mensleesbare tekst anders behandelt dan ruwe invoer, wat resulteert in betrouwbare, consistente en gemakkelijk leesbare resultaten.

Hoe Een Type Te Definiëren

Oplossing

Hoe Een Type Te Definiëren

Oplossing