Summary  
This chapter explains how to use the step parameter in string slicing to select characters at defined intervals or in reverse order by specifying start, end, and step (including negative steps).

General domain of usage  
Parsing structured string data.

A fatia pode ser aprimorada com um argumento de passo, que permite extrair caracteres em intervalos específicos.

Isso é útil quando se deseja selecionar a cada segundo caractere, pular letras ou extrair padrões de dados estruturados como números de fatura, códigos de transação ou relatórios.

```python
string[start : end : step]
```
- `start`: o índice onde a fatia começa (inclusivo)
- `end`: o índice onde a fatia termina (exclusivo)
- `step`: o intervalo (por exemplo, 2 significa a cada segundo caractere)

Também é possível **omitir** um ou mais valores:

- `string[::2]` pega a cada segundo caractere do início ao fim;
- `string[5::3]` começa no índice 5 e pega a cada terceiro caractere;
- `string[:-2:2]` pega a cada segundo caractere do início até (mas não incluindo) o penúltimo caractere.

## Exemplo


Watch this video to see visual demonstrations of string slicing in Python using the step argument. You'll learn how to extract every second or third character from a string, and see real-world examples — like pulling control codes from report filenames. This will help you understand how the start, end, and step values work together to select specific characters in a string.

code = "TXN-2024-INV-0007"
sliced = code[0:13:5]
print(sliced)  # Output: T0N

- Início no índice `0`
- Fim no índice `13` (exclusivo)
- Uso de passo igual a `5`, ou seja: pega a cada quinto caractere

Os caracteres nos índices `0`, `5` e `10` são `'T'`, `'0'` e `'N'`, portanto a saída é `'T0N'`.

Esse tipo de fatiamento pode ser utilizado para extrair iniciais ou códigos de controle de strings estruturadas em sistemas financeiros ou de documentos.

import ast
import csv
import importlib
import re
import unittest


# Global Helper Function for Dynamic Feedback
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        # Overwrite the test method name so the test runner displays the success message
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        # Overwrite the test method name so the test runner displays the failure message
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def _test_variable_equals_string(self, var_name, expected):
        # Local import to prevent caching issues across test runs
        import user_code
        importlib.reload(user_code)

        if not hasattr(user_code, var_name):
            return (False, f"Expected variable '{var_name}' to be defined.")

        value = getattr(user_code, var_name)
        if str(value) != str(expected):
            return (
                False,
                f"Expected variable '{var_name}' to equal '{expected}', but got '{value}'.",
            )

        return (True, f"The variable '{var_name}' equals '{expected}'.")

    def test_year_code_value(self):
        passed, result_text = self._test_variable_equals_string(
            "year_code", "22"
        )

        # Route the results dynamically
        _dynamic_test(
            test_case=self,
            condition=passed,
            success_message="The variable 'year_code' equals '22'.",
            failure_message=result_text,
        )


# Additional Source Code Manipulation Helpers (Preserved for your platform)
def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()


def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False

    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(
            isinstance(target, ast.Name) and target.id == var_name
            for target in node.targets
        )
    ]

    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = "" * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i + 1 :]:
            if hasattr(next_node, "lineno"):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line + 1 : next_line] = []
        changed = True

    return "\\n".join(lines) if changed else code


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 realização de operações básicas e construa as habilidades fundamentais necessárias para escrever códigos Python limpos e eficientes.

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 é fundamental 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 dos dados brutos, alcançando resultados confiáveis, consistentes e de fácil leitura.

Tarefa de Fatiamento

Exemplo

Tarefa de Fatiamento

Exemplo

Solução