Objetivo

Compile dados da aplicação e envie cartas de resposta utilizando o módulo string.

Agora que o material para a construção da nova fazenda foi contabilizado, é hora de voltarmos nossa atenção para o novo pessoal da fazenda. Temos várias cartas que precisam ser enviadas para candidaturas a emprego; naturalmente, isso exigiria muita escrita, porém podemos usar o módulo string para compensar isso, permitindo-nos criar modelos e formatar textos para facilitar o manuseio de corpos de texto.

A importação do módulo string desta vez será um pouco diferente dos outros módulos, pois estaremos importando classes que estendem o módulo, e isso será executado da seguinte forma:

import string
from string import Template
from string import Formatter

Isso nos dá acesso ao módulo em si, bem como acesso às classes de template e formatação que incluem suas próprias funções. Para os nossos propósitos, usaremos as seguintes funções e classes:

• string.capwords(): Esta função converte as palavras de uma string para ter a capitalização apropriada, tornando a primeira letra de uma palavra maiúscula e o restante minúsculo, independentemente de como a string está formatada.
• Template(): Esta é uma classe de string, usada para criar um objeto template. Ela utiliza a função substitute() que permite configurar uma string e destacar um local usando o sinal $ para trocar dados. Isso permite que você crie strings modulares que podem ser usadas conforme necessário.
• Formatter(): Esta é uma classe de string, usada para formatar ou compor uma string. Funciona de maneira semelhante à classe Template(), mas é mais robusta e melhor para sequências maiores de strings. Utiliza a função format() que permite configurar uma string e inserir dados nela usando {}.

Comece caminhando até a marca X clara e utilizando a função read() enquanto está de frente para o arquivo, isso permitirá que você acesse pastas com o nome de vários candidatos. Essas pastas estão presentes como três (3) constantes de lista chamadas: folder_a, folder_b e folder_c.

Caminhe até a marca X escura sobre o tapete verde e de frente para a mesa. Crie três (3) listas chamadas: names_a, names_b e names_c. Use compreensões de lista com a função string.capwords() para formatar a capitalização correta dos nomes. Combine as listas com as constantes que possuem as mesmas letras em seus nomes; por exemplo, para names_a use a string.capwords() com folder_a, assim: names_a = [string.capwords(x) for x in folder_a]. Use essa mesma fórmula para popular names_b e names_c.

Crie uma lista chamada all_names e some as três (3) listas de nomes, assim: all_names = names_a + names_b + names_c. Isso combinará todas as listas em uma lista maior, siga isso utilizando uma função Python chamada join() que unirá todos os itens da lista em uma única string. Você também pode especificar o que colocar entre cada item da lista, declarando-o entre aspas, assim: all_names = ", ".join(all_templates). Use a função pré-escrita write() com a lista all_names para registrar todos os nomes com as capitalizações corretas.

Em seguida, caminhe até a marca X dourada e de frente para a mesa, aqui iremos configurar modelos. Aqui teremos dois objetos template pré-escritos chamados red_templates e blue_templates:

red_template = Template(
  "Hello, $name , thank you for applying for this position.")
blue_template = Template(
  "Esteemed , $name , your application has been approved.")

Cada um desses templates possui uma mensagem única, porém têm em comum um espaço reservado rotulado como $name. O símbolo $ é usado para indicar um espaço reservado que pode ser substituído por uma string de sua escolha, neste caso, conforme o título sugere, é um nome. Se nenhum valor for substituído, o template usará meramente o espaço reservado na própria string. Para complementar isso, crie uma lista chamada all_templates.

Crie um laço for com quatro (4) ciclos, com isso substituiremos os nomes nas três (3) listas de nomes pelos templates com os nomes incluídos. Por exemplo, aplicaremos o red_template à lista names_a. Use a função substitute() da classe Template() para substituir o espaço reservado $name no template pelos nomes da lista.

for x in range(4):
  names_a[x] = red_template.substitute(name=names_a[x]) 

Faça o mesmo com names_b e names_c; para names_b use o red_template também e para names_c use o blue_template.

Uma vez que todas as listas de nomes tenham sido preenchidas com os novos templates, é hora de revisá-las. Crie uma nova lista chamada all_templates e adicione todas as listas de nomes juntas, assim: all_templates = names_a + names_b + names_c. Use a mesma função join() de antes para compilar todos os nomes com template em uma forma legível, assim: all_templates = "\n".join(all_templates). Use a função pré-escrita write() com all_templates para delinear todos os cabeçalhos para os diferentes nomes.

Em seguida, caminhamos até a marca X escura sobre o tapete vermelho e de frente para a mesa, aqui iremos formatar e escrever o primeiro conjunto de cartas. Comece criando dois (2) objetos formatter chamados red_1 e red_2 com a denotação de classe, assim: red_1 = Formatter(), red_2 = Formatter(). Para a composição das cartas, crie uma lista chamada red_letters.

Assim como antes, teremos um laço for com quatro (4) ciclos; teremos dois conjuntos de strings pré-escritas que serão formatadas usando a função format() e terão as variáveis de nomes adicionadas a elas. Estas strings formatadas serão adicionadas à lista red_letters, formando uma lista abrangente de cartas que serão enviadas. Por exemplo, os objetos formatados red_1 serão formatados com a lista names_a e adicionados à lista red_letters.

for x in range(4):
  red_letters.append(red_1.format(
    "{} Orientation will begin next week, please report to the office..."
    , names_a[x]))

Faça o mesmo com o objeto formatador red_2 utilizando sua string pré-escrita e adicione names_b ao laço. Uma vez que tudo estiver configurado, use a função join() com red_letters para compilar os dados em um único arquivo, assim: red_letters = "\n".join(red_letters). Use a função write() com red_letters para registrar todas as cartas formatadas que serão enviadas.

Por fim, caminhe até a marca X escura sobre o tapete azul e de frente para a mesa, aqui iremos formatar e compor o último conjunto de cartas; assim como antes, crie dois (2) objetos formatter chamados blue_1 e blue_2 com a denotação de classe, assim: blue_1 = Formatter(), blue_2 = Formatter(). Crie uma lista blue_letters para formatar e compor todas as cartas.

Mais uma vez, crie um laço for com quatro (4) ciclos e use as strings pré-escritas para formatar as listas de nomes e adicioná-las à lista blue_letters utilizando a função format(). Neste caso, utilize os objetos formatadores blue_1 com a lista names_c e blue_2 com a lista names_b. Tudo isso é feito da mesma forma que sobre o tapete vermelho, mas usando valores diferentes, demonstrando a versatilidade do uso de formatos e templates. Uma vez finalizado, use a função write() com blue_letters para arquivar as últimas cartas e completar o nível.