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

Adquira uma compreensão sólida dos principais tipos de dados do Python e aprenda a utilizá-los de forma eficaz. Explore números, booleanos e strings por meio de exercícios práticos e exemplos aplicados. Desenvolva confiança na execução de operações básicas e construa as habilidades fundamentais necessárias para escrever código Python limpo e eficiente.

Descubra os conceitos essenciais dos tipos de dados numéricos em Python e aprenda a trabalhar com inteiros e números de ponto flutuante. Domine operações aritméticas básicas, explore o conceito de imutabilidade e obtenha experiência prática utilizando as funções e ferramentas integradas do Python para manipular números de forma eficiente em cenários do mundo real.

Obtenha uma compreensão clara do tipo de dado booleano, um subtipo especializado de dados numéricos que representa valores de verdade. Embora possa parecer desafiador no início, dominar booleanos é essencial para escrever programas lógicos e eficientes. Esta seção ajudará você a aplicar com confiança a lógica booleana em cenários de programação do mundo real.

Strings permitem trabalhar com texto em Python, desde exibir mensagens até processar entradas do usuário. Você explorará como criar, modificar e manipular strings de forma eficaz. Compreender strings é essencial para escrever programas interativos e comunicar informações de maneira clara por meio do código.

Aprenda a lidar com tipos de dados de forma eficaz para garantir precisão e consistência em seus programas. Converta valores para o tipo apropriado, limpe textos antes de comparações e separe operações numéricas da formatação de texto. Descubra também como gerenciar dados ausentes de maneira deliberada e tratar textos legíveis por humanos de forma diferente de entradas brutas, alcançando resultados confiáveis, consistentes e de fácil leitura.

Desafio: Mecanismo de Acesso e Benefícios de Ingresso

Solução

Awesome!

Desafio: Mecanismo de Acesso e Benefícios de Ingresso

Solução