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

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")

    def test_age(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "age") and isinstance(m.age, int) and m.age == 19,
            "Variable 'age' correctly set to int 19",
            f"Variable 'age' should be int 19, got {getattr(m, 'age', None)}"
        )

    def test_has_id(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "has_id") and isinstance(m.has_id, bool) and m.has_id is True,
            "Variable 'has_id' correctly set to True",
            f"Variable 'has_id' should be True, got {getattr(m, 'has_id', None)}"
        )

    def test_tier(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "tier") and m.tier == "VIP",
            "Variable 'tier' correctly parsed as 'VIP'",
            f"Variable 'tier' should be 'VIP', got {getattr(m, 'tier', None)}"
        )

    def test_seat_number_str(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "seat_number_str") and m.seat_number_str == "023",
            "Variable 'seat_number_str' correctly parsed as '023'",
            f"Variable 'seat_number_str' should be '023', got {getattr(m, 'seat_number_str', None)}"
        )

    def test_zone(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "zone") and m.zone == "A",
            "Variable 'zone' correctly parsed as 'A'",
            f"Variable 'zone' should be 'A', got {getattr(m, 'zone', None)}"
        )

    def test_seat_number(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "seat_number") and isinstance(m.seat_number, int) and m.seat_number == 23,
            "Variable 'seat_number' correctly converted to int 23",
            f"Variable 'seat_number' should be int 23, got {getattr(m, 'seat_number', None)}"
        )

    def test_is_adult(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "is_adult") and isinstance(m.is_adult, bool) and m.is_adult is True,
            "Variable 'is_adult' correctly set to True",
            f"Variable 'is_adult' should be True, got {getattr(m, 'is_adult', None)}"
        )

    def test_can_enter(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "can_enter") and isinstance(m.can_enter, bool) and m.can_enter is True,
            "Variable 'can_enter' correctly set to True",
            f"Variable 'can_enter' should be True, got {getattr(m, 'can_enter', None)}"
        )

    def test_vip_perk(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "vip_perk") and isinstance(m.vip_perk, bool) and m.vip_perk is True,
            "Variable 'vip_perk' correctly set to True",
            f"Variable 'vip_perk' should be True, got {getattr(m, 'vip_perk', None)}"
        )

    def test_member_fastlane(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "member_fastlane") and isinstance(m.member_fastlane, bool) and m.member_fastlane is False,
            "Variable 'member_fastlane' correctly set to False",
            f"Variable 'member_fastlane' should be False, got {getattr(m, 'member_fastlane', None)}"
        )

    def test_seat_ok(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "seat_ok") and isinstance(m.seat_ok, bool) and m.seat_ok is True,
            "Variable 'seat_ok' correctly set to True",
            f"Variable 'seat_ok' should be True, got {getattr(m, 'seat_ok', None)}"
        )

    def test_entry_granted(self):
        m = self.m
        _dynamic_test(
            self,
            hasattr(m, "entry_granted") and isinstance(m.entry_granted, bool) and m.entry_granted is True,
            "Variable 'entry_granted' correctly set to True",
            f"Variable 'entry_granted' should be True, got {getattr(m, 'entry_granted', None)}"
        )

    def test_summary(self):
        m = self.m
        expected = "VIP-023-A | age=19 | enter=True | vip=True | fastlane=False"
        _dynamic_test(
            self,
            hasattr(m, "summary") and isinstance(m.summary, str) and m.summary == expected,
            "Variable 'summary' correctly built with expected format and values",
            f"Variable 'summary' should be '{expected}', got {getattr(m, 'summary', None)}"
        )


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

解答