Como Usar Formatadores de String no Python 3

###Introdução

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

Este tutorial irá orientá-lo através de alguns dos usos comuns de formatação em Python, os quais podem ajudar a tornar seu código e programa mais legíveis e amigáveis para o 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ê ainda não configurou um ambiente de programação, você 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 o 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 {} — 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 onde 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 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 de 5 na string onde estavam as chaves:

Sammy has 5 balloons.

Também podemos atribuir uma variável para ser igual ao valor de uma string que possui 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 "open source" com a string maior, substituindo as chaves na string original.

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

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

Você pode usar vários 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 vírgula

Output
Sammy loves open-source software.

Para adicionar outra substituição, adicionamos um segundo par de chaves na string original. Em seguida, passamos duas strings para o método str.format(), separando-as por 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 de string e inteiro. Cada um desses valores é separado por vírgula.

##Reordenando Formatações com Argumentos Posicionais e por Palavra-chave

Quando deixamos 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 formatação com dois pares de chaves vazias com dois valores passados resultará em:

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 "tubarão", e o segundo par é substituído pelo valor da string "peixe-piloto".

Os valores que existem dentro do método parecem com isso:

("shark", "pilot fish")

Essencialmente, 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 chaves, pois estamos chamando os valores na tupla em 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 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 se refere à 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 a serem passados para eles, para que possamos entender melhor como podemos reordenar 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 em 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 alterar 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 número de índice 3, chamamos primeiro o último valor de "shark". Os outros números de índice incluídos como parâmetros alteram a ordem como as palavras aparecem dentro da string original.

Além de 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 os argumentos posicionais e podemos mover esses argumentos 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 Tipo

Podemos incluir mais parâmetros dentro das chaves da 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 dado que você está usando com o formatador.

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

Vamos dar uma olhada em um exemplo onde temos um inteiro passado pelo método, mas queremos exibi-lo como um float adicionando o argumento do 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!

Nós usamos a sintaxe de {nome_do_campo:conversão} para o primeiro campo de substituição de chaves para exibir um float. As segundas chaves apenas utilizam o primeiro parâmetro {nome_do_campo}.

No exemplo acima, há muitos números sendo 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 do 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 da seguinte forma:

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 não sejam mostradas casas decimais, pode escrever seu formatador da seguinte maneira:

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

Output
Sammy ate 76 percent of a pizza!

Isso não converte seu float para um inteiro, mas sim limita o número de casas mostradas após o ponto decimal.

##Substituições de Variáveis com 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 visualmente muitos dados.

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, demos 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. < vai alinhar à esquerda o texto em um campo, ^ vai centralizar o texto no campo e > vai alinhar à direita.

Vamos alinhar à esquerda o número 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 formatação, o Python preencherá o campo com caracteres de espaço em branco. Podemos modificar isso para ser um caractere diferente especificando o caractere que desejamos que seja diretamente após o dois pontos:

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

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

Estamos aceitando a string que está sendo passada para str.format() na posição do índice 0, já que não especificamos o contrário, 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, incluindo 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 casas 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 pelo 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!

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

##Usando Formatação para Organizar Dados

As formatações podem ser vistas da melhor maneira quando estão sendo usadas para organizar muitos dados de maneira visual. Se estivermos mostrando bancos de dados para usuários, usar formatações para aumentar o tamanho do campo e modificar o alinhamento pode tornar sua saída mais legível.

Vamos dar uma olhada em um loop for típico 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 formatações 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 inteiros. Neste exemplo, acomodamos o tamanho de cada saída esperada, dando 2 espaços extras de caracteres 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, trocar números de índice de nomes de campos e 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 forma 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.