Como Usar Formadores de Strings no Python 3

###Introdução

O método str.format() da classe string em Python permite que você faça substituições de variáveis e formatação de valores. Isso permite que você concatene elementos juntos dentro de uma string através de formatação posicional.

Este tutorial irá guiá-lo através de alguns dos usos comuns de formatação em Python, que podem ajudar a tornar seu código e programa mais legíveis e amigáveis ao usuário.

Pré-requisitos

Você deve ter o Python 3 instalado e um ambiente de programação configurado em seu computador ou servidor. Se você não tiver um ambiente de programação configurado, pode consultar os guias de instalação e configuração para um ambiente de programação local ou para um ambiente de programação em seu servidor apropriado para seu sistema operacional (Ubuntu, CentOS, Debian, etc.)

##Usando Formatação

Os formateadores funcionam colocando um ou mais campos de substituição ou espaços reservados – definidos por um par de chaves curvas {} – em uma string e chamando o método str.format(). Você passará para o método o valor que deseja concatenar com a string. Este valor será passado no mesmo lugar em que seu espaço reservado estiver posicionado quando você executar o programa.

Vamos imprimir uma string que usa um formatador:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

No exemplo acima, construímos uma string com um par de chaves curvas como espaço reservado:

"Sammy has {} balloons."

Em seguida, adicionamos o método str.format() e passamos o valor do inteiro 5 para esse método. Isso coloca o valor 5 na string onde estavam as chaves curvas:

Sammy has 5 balloons.

Também podemos atribuir uma variável para ser igual ao valor de uma string que tenha espaços reservados de formatação:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

Neste segundo exemplo, concatenamos a string "código aberto" com a string maior, substituindo as chaves curvas na string original.

Os formateadores em Python permitem que você use chaves curvas como espaços reservados para valores que você passará com o método str.format().

##Usando Formateadores com Múltiplos Espaços Reservados

Você pode usar múltiplos pares de chaves ao usar formatadores. Se quisermos adicionar outra substituição de variável à frase acima, podemos fazer isso adicionando um segundo par de chaves e passando um segundo valor para o método:

new_open_string = "Sammy loves {} {}."                      #2 espaços reservados {}
print(new_open_string.format("open-source", "software"))    #Passe 2 strings para o método, separadas por uma vírgula

Output
Sammy loves open-source software.

Para adicionar outra substituição, adicionamos um segundo par de chaves à string original. Em seguida, passamos duas strings para o método str.format(), separando-as por uma vírgula.

Seguindo a mesma sintaxe, podemos adicionar substituições adicionais:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 espaços reservados {}
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Passe 4 strings para o método

Output
Sammy loves open-source software, and has 5 balloons.

No sammy_string, adicionamos 4 pares de chaves como espaços reservados para substituição de variável. Em seguida, passamos 4 valores para o método str.format(), misturando tipos de dados string e inteiro. Cada um desses valores é separado por uma vírgula.

##Reordenando formatadores com argumentos posicionais e de palavras-chave

Quando deixamos as chaves vazias sem nenhum parâmetro, o Python substituirá os valores passados pelo método str.format() na ordem. Como vimos até agora, uma construção de formatador com dois pares de chaves vazias com dois valores passados será assim:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

O primeiro par de chaves é substituído pelo valor da string "shark", e o segundo par é substituído pelo valor da string "pilot fish".

Os valores que existem dentro do método parecem assim:

("shark", "pilot fish")

Essencialmente, eles são do tipo de dados tupla e cada valor individual contido na tupla pode ser chamado pelo seu número de índice, que começa com o número de índice 0.

Podemos passar esses números de índice entre chaves, que servem como espaços reservados na string original:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

No exemplo acima, a saída será o que obtemos sem passar os números de índice entre as chaves, já que estamos chamando os valores da tupla na ordem:

Output
Sammy the shark has a pet pilot fish!

Mas, se invertermos os números de índice com os parâmetros dos espaços reservados, podemos inverter os valores que estão sendo passados para a string:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Se você chamar um número de índice 2 em uma tupla que tem valores nas posições de índice 0 e 1, então você está chamando um valor que está fora do alcance. Quando você chama um número de índice que está fora do alcance, você receberá uma mensagem de erro:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

A mensagem de erro que vemos refere-se à tupla tendo valores apenas nos números de índice 0 e 1, portanto, colocando o número de índice 2 fora do alcance.

Vamos adicionar mais alguns espaços reservados e alguns valores para passar para eles, para que possamos entender melhor como podemos reorganizar os formatadores. Primeiro, aqui está uma nova string com quatro espaços reservados:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Sem parâmetros, os valores que são passados para o método str.format() são concatenados na string na ordem.

Os valores de string contidos na tupla correspondem aos seguintes números de índice:

Vamos usar os números de índice dos valores para mudar a ordem em que aparecem na string:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Já que começamos com o índice número 3, chamamos primeiro o último valor de "shark". Os outros números de índice incluídos como parâmetros mudam a ordem de como as palavras aparecem dentro da string original.

Além dos argumentos posicionais, também podemos introduzir argumentos de palavra-chave que são chamados pelo nome da palavra-chave:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

Este exemplo mostra o uso de um argumento de palavra-chave sendo usado com argumentos posicionais. Podemos preencher o argumento de palavra-chave pr junto com argumentos posicionais e podemos mover esses argumentos ao redor para mudar a string resultante:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

Argumentos posicionais e de palavra-chave usados com formatadores de string nos dão mais controle sobre a manipulação de nossas strings originais através da reordenação.

##Especificando o Tipo

Podemos incluir mais parâmetros dentro das chaves de nossa sintaxe. Usaremos a sintaxe do código de formato {nome_do_campo:conversão}, onde nome_do_campo especifica o número de índice do argumento para o método str.format() que passamos pela seção de reordenação, e conversão se refere ao código de conversão do tipo de dados que você está usando com o formatador.

O tipo de conversão refere-se ao código de tipo de caractere que o Python utiliza. Os códigos que estaremos usando aqui são s para string, d para exibir inteiros decimais (base 10), e f que usaremos para exibir floats com casas decimais. Você pode ler mais sobre a Linguagem Mini de Especificação de Formato através da documentação oficial do Python 3.

Vamos olhar um exemplo onde temos um inteiro passado através do método, mas queremos exibí-lo como um float adicionando o argumento de tipo de conversão f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

Usamos a sintaxe de {nome_do_campo:conversão} para o primeiro campo de substituição de chave para produzir um float. As segundas chaves apenas utilizam o primeiro parâmetro {nome_do_campo}.

No exemplo acima, há muitos números exibidos após o ponto decimal, mas você pode limitá-los. Quando você está especificando f para valores float, você pode adicionalmente especificar a precisão desse valor incluindo um ponto final . seguido pelo número de dígitos após o decimal que você gostaria de incluir.

Se Sammy comeu 75.765367% da pizza, mas não precisamos de um alto nível de precisão, podemos limitar os lugares após o decimal para 3 adicionando .3 antes do tipo de conversão f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

Se quisermos apenas um lugar decimal, podemos reescrever a string e o método assim:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Observe que modificar a precisão fará com que o número seja arredondado.

Embora exibamos um número sem casas decimais como um float, se tentarmos alterar o float para um inteiro usando o tipo de conversão d, receberemos um erro:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

Se você deseja que nenhuma casa decimal seja mostrada, pode escrever o seu formatador assim:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

Isso não irá converter seu float em um inteiro, mas sim limitar o número de casas mostradas após o ponto decimal.

## Substituições Variáveis de Preenchimento

Como os espaços reservados são campos de substituição, você pode preencher ou criar espaço ao redor de um elemento aumentando o tamanho do campo por meio de parâmetros adicionais. Isso pode ser útil quando precisamos organizar muitos dados visualmente.

Podemos adicionar um número para indicar o tamanho do campo (em termos de caracteres) após os dois pontos : nas chaves da nossa sintaxe:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

No exemplo acima, atribuímos ao número 5 um tamanho de campo de 4 caracteres e à string balloons um tamanho de campo de 16 caracteres (porque é uma string longa).

Como vemos, por padrão, as strings são alinhadas à esquerda dentro do campo, e os números são alinhados à direita. Você pode modificar isso colocando um código de alinhamento após os dois pontos. < irá alinhar o texto à esquerda em um campo, ^ irá centralizar o texto no campo, e > irá alinhá-lo à direita.

Vamos alinhar o número à esquerda e centralizar a string:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

Agora vemos que 5 está alinhado à esquerda, fornecendo espaço no campo antes de red, e balloons está centralizado em seu campo com espaço à esquerda e à direita dele.

Por padrão, quando ampliamos um campo com formatadores, o Python preencherá o campo com caracteres de espaço em branco. Podemos modificar isso para ser um caractere diferente especificando o caractere que queremos diretamente após os dois pontos:

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

Estamos aceitando a string que está sendo passada para str.format() na posição de índice 0, pois não especificamos de outra forma, incluindo os dois pontos, e especificando que usaremos * em vez de espaço para preencher o campo. Estamos centralizando a string com ^, especificando que o campo tem 20 caracteres de tamanho, e também indicando que estamos trabalhando com um tipo de conversão de string ao incluir s.

Podemos combinar esses parâmetros com outros parâmetros que já usamos antes:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

Nos parâmetros dentro das chaves, especificamos o número do campo de índice do float e incluímos os dois pontos, indicamos o tamanho do número do campo e incluímos o ponto final, escrevemos o número de lugares após o ponto decimal e depois especificamos o tipo de conversão de f.

##Usando Variáveis

Até agora, passamos inteiros, floats e strings para o método str.format(), mas também podemos passar variáveis através do método. Isso funciona como qualquer outra variável.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

Podemos usar variáveis tanto para a string original quanto para o que é passado para o método:

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

As variáveis podem ser facilmente substituídas para cada parte da nossa construção de sintaxe do formatador. Isso torna mais fácil trabalhar quando estamos recebendo entrada gerada pelo usuário e atribuindo esses valores às variáveis.

##Usando Formadores para Organizar Dados

Os formadores podem ser vistos da melhor maneira quando estão sendo usados para organizar muitos dados de forma visual. Se estivermos mostrando bancos de dados aos usuários, usar formadores para aumentar o tamanho do campo e modificar o alinhamento pode tornar sua saída mais legível.

Vamos dar uma olhada em um típico loop for em Python que imprimirá i, i*i e i*i*i no intervalo de 3 a 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Embora a saída esteja organizada de alguma forma, os números transbordam para as colunas uns dos outros, tornando a parte inferior da saída menos legível. Se estiver trabalhando com um conjunto de dados maior com muitos números pequenos e grandes, isso pode representar um problema.

Vamos usar formadores para dar mais espaço a esses números:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

Aqui, em nossas chaves, não adicionamos o nome do campo para o número do índice e começamos com dois pontos, seguido pelo número do tamanho do campo e um tipo de conversão d já que estamos trabalhando com números inteiros. Neste exemplo, acomodamos o tamanho de cada saída esperada, dando 2 espaços de caracteres extras para cada uma, dependendo do tamanho máximo possível do número, então nossa saída fica assim:

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

Podemos especificar um número de tamanho de campo consistente para ter colunas uniformes, garantindo que acomodemos os números maiores:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

Podemos também manipular o alinhamento das colunas adicionando <, ^ e > para o alinhamento do texto, trocar d por f para adicionar casas decimais, alterar os números de índice dos nomes dos campos e muito mais para garantir que estamos exibindo os dados como desejamos.

##Conclusão

O uso de formatadores para substituição de variáveis pode ser uma maneira eficaz de concatenar strings e organizar valores e dados. Os formatadores representam uma maneira básica, mas não descritiva, de passar substituições de variáveis para uma string e são úteis para garantir que a saída seja legível e amigável ao usuário.