Formatação de strings

Você já aprendeu o que são as strings e como usá-las para representar textos. Agora, vamos descobrir como formatar e exibir strings de diferentes maneiras.

Caracteres de escape em strings

Na lição anterior, você viu que se quiser usar o mesmo tipo de aspas tanto em volta quanto dentro da sua string, você vai receber uma mensagem de erro. Mas existe uma alternativa para isso!

O problema de usar o mesmo tipo de aspas era que o Python não conseguia entender que uma estava dentro da outra. Ele interpretava que o primeiro par de aspas se fechava e o segundo se abria bem depois, deixando uma ou mais palavras soltas fora das strings, no espaço entre os dois pares de aspas.

Mas olha só: existe uma forma simples de avisar o interpretador que ele não deve ler dessa forma. Isso pode ser feito com o que chamamos de caractere de escape (\).

Funciona assim:

1print("Ele disse: \"Python é incrível!\"")
2
3# Saída:
4# Ele disse: "Python é incrível!"

Ele indica pro interpretador que o caractere que vem depois dele não deve ser interpretado como um comando da linguagem, mas sim exibido literalmente como escrevemos.

Com isso, no exemplo acima, as aspas, que normalmente indicariam para o Python que uma string começou e terminou, passam a ser lidas só como aspas dentro do texto da string.

Para além do uso com as aspas, seja como (\") ou (\'), há outros casos em que o caractere de escape pode ser muito útil em nossas strings. Ele pode servir para quebrar linhas dentro do texto (\n), acrescentar um espaço de tabulação (\t) como quando usamos o Tab do nosso teclado e para termos a própria barra invertida, também chamada de contrabarra (\\), dentro da nossa string.

Veja alguns exemplos:

1print("Primeira linha\nSegunda linha")
2print("Texto com\ttabulação")
3print("Caminho: C:\\Users\\Diego")
4
5# Saída:
6# Primeira linha
7# Segunda linha
8# Texto com    tabulação
9# Caminho: C:\Users\Diego

Imprimindo múltiplas variáveis

Nem sempre queremos mostrar o valor de uma só variável. Em algumas situações, vamos precisar exibir múltiplas variáveis ao mesmo tempo. É aí que entram outras formas de usar o print() para combinar diferentes valores na mesma linha.

É possível fazer isso separando as variáveis por vírgulas dentro do print():

1x = "Python"
2y = "é"
3z = "incrível"
4
5print(x, y, z)
6
7# Saída:
8# Python é incrível

Outra opção é usar o operador + para juntar strings. Chamamos isso de concatenação.

1x = "Python"
2y = "é"
3z = "incrível"
4
5print(x + y + z)
6
7# Saída:
8# Pythonéincrível

Mas repare que no texto de saída acima, as palavras ficaram grudadas.

Diferente das vírgulas, o operador + une o texto exatamente como estão, sem adicionar espaços entre as palavras. Por isso, precisamos acrescentar um espaço no final das strings que queremos que fiquem separadas da string seguinte que será impressa.

Observe a diferença:

1x = "Python "   # acrescentamos um espaço depois da palavra
2y = "é "        # acrescentamos um espaço depois da palavra
3z = "incrível"
4
5print(x + y + z)
6
7# Saída:
8# Python é incrível

E atenção: o operador + só funciona para unir strings com outras strings. Se você tentar unir uma string com um valor numérico, por exemplo, vai dar errado:

1x = 7
2y = "Belo"
3
4print(x + y)
5
6# Saída:
7# Traceback (most recent call last):
8#   File "<python-input-1>", line 1, in <module>
9#     print(x + y)
10#           ~~^~~
11# TypeError: unsupported operand type(s) for +: 'int' and 'str'

Se você quiser juntar tipos diferentes de dados em uma string, separe as variáveis por vírgulas:

1x = 7
2y = "Belo"
3print(x, y)
4
5# Saída:
6# 7 Belo

Mas como vimos acima, as vírgulas adicionam automaticamente um espaço entre cada item impresso. Caso você queira exibir números e textos juntos, sem esse espaço extra, você pode usar o casting, que vimos antes, para converter o número para o tipo string e concatenar tudo com o operador +:

1x = 7         # aqui, o 7 é do tipo int
2y = "Belo"
3
4x = str(x)    # convertemos o 7 do tipo int para o "7" do tipo str
5
6print(x + y)  # concatenamos as strings "7" e "Belo"
7
8# Saída:
9# 7Belo

Resumindo, o print() permite exibir múltiplas variáveis de uma só vez, e podemos fazer isso de duas formas:

• Com vírgulas (,): une os valores automaticamente com um espaço entre eles e imprime várias de tipos diferentes juntas.
• Com o operador de concatenação (+): une as strings exatamente como estão. Se quiser espaços, eles precisam ser incluídos manualmente dentro das strings. Não funciona para unir strings com outros tipos de dados.

Repetindo strings

O + não é o único símbolo da matemática que usamos com strings. Além dele, o Python também permite usar o operador de multiplicação * e o resultado é bem interessante!

Podemos repetir uma string quantas vezes quisermos, como se estivéssemos mesmo multiplicando aquele texto:

1print("Python " * 3)
2
3# Saída:
4# Python Python Python

Esse recurso é útil quando queremos criar separadores, padrões ou mensagens repetidas no terminal.

1print("=" * 16)
2print("TABELA DE PONTOS")
3print("=" * 16)
4
5# Saída:
6# ================
7# TABELA DE PONTOS
8# ================

Mas fique de olho: só é possível usar esse operador para repetir strings por um número de vezes do tipo int!

F-strings

Depois de conhecer os operadores + e *, é hora de ver uma forma ainda mais poderosa de formatar strings!

Apesar de funcionarem bem, as formas de unir strings com strings ou outros tipos de dados que vimos até agora são trabalhosas. Elas têm várias regras e exigem bastante cuidado para chegarmos no resultado que queremos.

Seria legal se desse para só escrever nossos textos e inserir as variáveis direto nele, sem se preocupar com vírgulas ou concatenação, certo? A boa notícia é que é possível fazer isso!

Antes da versão 3.6 do Python, você podia usar o método format(). Não precisa se preocupar agora em entender o que é um método, tá bom?

Você só precisa saber que ele funciona como uma função, ou seja, de forma parecida com o print() e o input(). Uma diferença é que aqui, ele aparece no final da frase ou da variável que contém a frase e um ponto é usado para unir a função e o texto.

Cada par de chave corresponde à variável que aparece dentro dos parênteses da função format e com ela, podemos acrescentar diferentes tipos de dados em nossa string:

1nome = "Ana"
2idade = 25
3print("Meu nome é {} e tenho {} anos.".format(nome, idade))
4
5# Saída:
6# Meu nome é Ana e tenho 25 anos.

Apesar de funcionar bem, esse formato é mais longo e menos intuitivo. Nem sempre fica tão claro qual variável aparece em qual {}, por exemplo.

Por isso, o uso do format() é recomendado apenas para manutenção de códigos antigos.

Se você estiver começando um código do zero ou usando uma versão do Python a partir da 3.6, o ideal é usar as f-strings.

Basta colocar a letra f antes das aspas que iniciam sua string. Depois, você acrescenta um par de chaves ({}) para cada variável ou expressão que for usar. Dentro do par de chaves, vem o nome da variável.

Observe:

1nome = "Ana"
2idade = 25
3print(f"Meu nome é {nome} e tenho {idade} anos.")
4
5# Saída:
6# Meu nome é Ana e tenho 25 anos.

Assim, você sempre sabe qual variável está aparecendo em qual parte do texto.

Podemos também realizar operações dentro das chaves:

1preco = 50
2print(f"O dobro do preço é {preco * 2} reais")
3
4# Saída:
5# O dobro do preço é 100 reais

Formatando números

As f-strings não só permitem usar valores numéricos diretamente na string, mas também controlar como eles aparecem. Para mostrar um número com duas casas decimais, por exemplo, usamos o :.2f:

1preco = 59
2print(f"O preço é {preco:.2f} reais")
3
4# Saída:
5# O preço é 59.00 reais

Ele indica que duas casas decimais devem ser exibidas depois da parte inteira do valor guardado na variável preco. Caso seja um número com mais de 2 casas decimais, ele vai arredondar o número seguindo a seguinte tática:

• Se o dígito seguinte for maior que 5 → arredonda pra cima.
• Se for menor que 5 → arredonda pra baixo.
• Se for exatamente 5 → vai para o número par mais próximo.

1print(f"{1.234:.2f}")  # 1.23  → arredondou para baixo
2print(f"{1.236:.2f}")  # 1.24  → arredondou para cima
3print(f"{1.245:.2f}")  # 1.24  → 0.245 está mais próximo de 0.24 (maior)

Caso o valor tenha menos de 2 casas decimais, zeros serão acrescentados para que existam 2 casas.

Espaçamento e alinhamento

Por fim, também é possível ajustar o alinhamento do texto diretamente dentro das chaves:

1print(f"{"O":5}Python")   # faz com que o texto das chaves ocupe 5 caracteres
2print(f"{"O":<5}Python")  # < alinha o "O" à esquerda e demais caracteres à direita
3print(f"{"O":>5}Python")  # > alinha o "O" à direita e demais caracteres à esquerda
4print(f"{"O":^5}Python")  # ^ centraliza o "O"
5print(f"{"TeAmo":5}Python")  # "TeAmo" ocupa todos os 5 espaços
6
7# Saída:
8# O    Python
9# O    Python
10#     OPython
11#   O  Python
12# TeAmoPython

O número dentro das chaves indica a largura mínima do campo. Assim, como o O ocupa apenas 1 dos 5 espaços que o {:5} reserva para esse valor, 4 espaços ficam vazios ao redor dele e podemos alinhar o O nesse espaço com os símbolos <, ^ e >.

No caso da palavra "TeAmo", ela sozinha ocupa os 5 espaços reservados, então não sobram espaços em branco.