Summary  
This chapter covers Python’s string slicing syntax, showing how to extract substrings by specifying start, end, and step indices and how to use open-ended slicing patterns. It explains both fixed-range slicing and omitting components for flexible extraction.

General domain of usage  
Text processing

import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

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

        cls.exp_name_clean = "Ada Lovelace"
        cls.exp_has_quick = True
        cls.exp_inside_parens = "quick"
        cls.exp_o_count = 4
        cls.exp_domain = "example.com"
        cls.exp_report = f"{cls.exp_name_clean} | {cls.exp_domain} | {cls.exp_o_count}"

    def test_name_clean(self):
        ok = hasattr(self.m, "name_clean") and self.m.name_clean == self.exp_name_clean
        used_strip = re.search(r"full_name\s*\.\s*strip\s*\(\s*\)", self.src)
        _dynamic_test(self, ok and used_strip,
                      "name_clean computed correctly",
                      "name_clean computed incorrectly")

    def test_has_quick_and_o_count(self):
        ok = hasattr(self.m, "has_quick") and hasattr(self.m, "o_count")
        vals = ok and self.m.has_quick == self.exp_has_quick and self.m.o_count == self.exp_o_count
        pat_quick = re.search(r'''["']quick["']\s+in\s+sentence\s*\.\s*lower''', self.src)
        pat_count = re.search(r'''sentence\s*\.\s*lower\s*\(\s*\)\s*\.\s*count\s*\(\s*["']o["']\s*\)''', self.src)
        _dynamic_test(self, vals and pat_quick and pat_count,
                      "has_quick and o_count computed correctly",
                      "has_quick or o_count computed incorrectly")

    def test_inside_parens(self):
        ok = hasattr(self.m, "inside_parens") and self.m.inside_parens == self.exp_inside_parens
        slice_pat = re.search(r"sentence\s*\[\s*start\s*\+\s*1\s*:\s*end\s*\]", self.src)
        _dynamic_test(self, ok and slice_pat,
                      "inside_parens computed correctly",
                      "inside_parens computed incorrectly")

    def test_domain(self):
        ok = hasattr(self.m, "domain") and self.m.domain == self.exp_domain
        pat_strip = re.search(r"email\s*\.\s*strip\s*\(\s*\)\s*\.\s*lower\s*\(\s*\)", self.src)
        pat_find = re.search(r'''find\s*\(\s*["']@["']\s*\)''', self.src)
        _dynamic_test(self, ok and pat_strip and pat_find,
                      "domain computed correctly",
                      "domain computed incorrectly")

    def test_report(self):
        ok = hasattr(self.m, "report") and self.m.report == self.exp_report
        pat_f = re.search(r'''f["']\{name_clean\}.*\{SEP\}.*\{domain\}.*\{SEP\}.*\{o_count\}["']''', self.src)
        _dynamic_test(self, ok and pat_f,
                      "report computed correctly",
                      "report 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: Exercícios de Fatiamento e Busca

Solução

Awesome!

Desafio: Exercícios de Fatiamento e Busca

Solução