Summary  
This chapter demonstrates how to use the str() function to convert non-string values into strings for concatenation in code.

General domain of usage  
Formatting printed output

import unittest
import importlib
import re

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)

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.m = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.src = f.read()

        # Expected values
        cls.exp_age = 19
        cls.exp_has_id = True
        cls.exp_tier = "VIP"
        cls.exp_seat_number_str = "023"
        cls.exp_zone = "A"
        cls.exp_seat_number = 23
        cls.exp_is_adult = True
        cls.exp_can_enter = True
        cls.exp_vip_perk = True
        cls.exp_member_fastlane = False
        cls.exp_seat_ok = True
        cls.exp_entry_granted = True
        cls.exp_summary = f"{cls.exp_tier}-{cls.exp_seat_number_str}-{cls.exp_zone} | age={cls.exp_age} | enter={cls.exp_entry_granted} | vip={cls.exp_vip_perk} | fastlane={cls.exp_member_fastlane}"

    def test_conversions(self):
        ok = hasattr(self.m, "age") and hasattr(self.m, "has_id")
        type_ok = ok and isinstance(self.m.age, int) and isinstance(self.m.has_id, bool)
        val_ok = ok and self.m.age == self.exp_age and self.m.has_id == self.exp_has_id
        pat_age = re.search(r'''int\s*\(\s*age_str\s*\.\s*strip\s*\(\s*\)\s*\)''', self.src)
        pat_hasid = re.search(r'''casefold\s*\(\s*\)\s*==\s*["']yes["']''', self.src)
        _dynamic_test(self, type_ok and val_ok and pat_age and pat_hasid,
                      "age and ID conversions correct", "age and ID conversions incorrect")

    def test_ticket_parts(self):
        ok = all(hasattr(self.m, v) for v in ["tier", "seat_number_str", "zone", "seat_number"])
        val_ok = ok and self.m.tier == self.exp_tier and self.m.seat_number_str == self.exp_seat_number_str and self.m.zone == self.exp_zone and self.m.seat_number == self.exp_seat_number
        pat_tier = re.search(r'''ticket_code\s*\[\s*:\s*3\s*\]''', self.src)
        pat_num = re.search(r'''ticket_code\s*\[\s*4\s*:\s*7\s*\]''', self.src)
        pat_zone = re.search(r'''ticket_code\s*\[\s*-1\s*\]''', self.src)
        pat_int = re.search(r'''int\s*\(\s*seat_number_str\s*\)''', self.src)
        _dynamic_test(self, val_ok and pat_tier and pat_num and pat_zone and pat_int,
                      "ticket parts parsed correctly", "ticket parts parsed incorrectly")

    def test_rules(self):
        names = ["is_adult", "can_enter", "vip_perk", "member_fastlane", "seat_ok", "entry_granted"]
        ok = all(hasattr(self.m, n) for n in names)
        val_ok = (
            ok and
            self.m.is_adult == self.exp_is_adult and
            self.m.can_enter == self.exp_can_enter and
            self.m.vip_perk == self.exp_vip_perk and
            self.m.member_fastlane == self.exp_member_fastlane and
            self.m.seat_ok == self.exp_seat_ok and
            self.m.entry_granted == self.exp_entry_granted
        )
        patterns = [
            r'''age\s*>=\s*adult_age''',
            r'''has_id\s*and\s*is_adult''',
            r'''tier\s*==\s*["']VIP["']''',
            r'''is_member\s*and\s*can_enter''',
            r'''1\s*<=\s*seat_number\s*<=\s*max_seat_number''',
            r'''can_enter\s*and\s*seat_ok'''
        ]
        _dynamic_test(self, val_ok and all(re.search(p, self.src) for p in patterns),
                      "rules computed correctly", "rules computed incorrectly")

    def test_summary(self):
        ok = hasattr(self.m, "summary") and self.m.summary == self.exp_summary
        pat = re.search(r'''f["']\{tier\}-\{seat_number_str\}-\{zone\}.*\{age\}.*\{entry_granted\}.*\{vip_perk\}.*\{member_fastlane\}["']''', self.src)
        _dynamic_test(self, ok and pat, "summary computed correctly", "summary computed incorrectly")

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.

Uitdaging: Toegangs- en Ticketvoordelen-Engine

Oplossing

Uitdaging: Toegangs- en Ticketvoordelen-Engine

Oplossing