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

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

Challenge: Access & Ticket Perks Engine

Solution

Awesome!

Challenge: Access & Ticket Perks Engine

Solution