Formatação de Strings

A formatação de strings é a forma de incorporar valores de variáveis em texto. Python oferece três abordagens: o operador legado %, o versátil método str.format() e a sintaxe moderna de f-string introduzida no Python 3.6. Cada uma produz o mesmo resultado para casos simples, mas diferem em poder, legibilidade e a versão do Python que exigem.

Este capítulo aborda:

• O operador % e seus códigos de tipo
• str.format() com marcadores posicionais, por índice e por palavra-chave
• f-strings — expressões inline e o especificador de depuração =
• Especificadores de formato: largura, alinhamento, precisão e bases numéricas
• Como escolher o método certo para cada situação

Capítulos relacionados: Python Strings · Concatenar Strings · Caracteres de Escape · Métodos de String

O Operador %

O operador % é o estilo mais antigo de formatação de strings em Python, inspirado no printf da linguagem C. Você coloca códigos de tipo dentro da string como marcadores e fornece os valores após o sinal %.

Códigos de tipo comuns

Formatando strings com %s e %d

My name is John and I am 30 years old.

Quando há mais de um valor, passe-os em uma tupla. Os valores são associados aos marcadores da esquerda para a direita:

item = "coffee"
price = 2.50
qty = 3
print("Item: %s | Price: $%.2f | Qty: %d" % (item, price, qty))

Item: coffee | Price: $2.50 | Qty: 3

O código de formato %.2f arredonda o float para 2 casas decimais.

Quando usar %: Principalmente ao trabalhar com código muito antigo ou bases de código Python 2. Para código novo, prefira str.format() ou f-strings.

str.format()

O método str.format() usa marcadores com chaves {} e é mais flexível que %. Ele suporta argumentos posicionais, reutilização por índice e argumentos nomeados por palavra-chave.

Marcadores Posicionais

As chaves vazias {} são preenchidas da esquerda para a direita com os argumentos passados para format():

Formatando strings com o método format em Python

My name is John and I am 30 years old.

Marcadores por Índice

Coloque um número dentro das chaves para selecionar um argumento específico. Você também pode repetir o mesmo argumento:

name = "John"
age = 30
print("{0} is {1} years old and {0} likes Python.".format(name, age))

John is 30 years old and John likes Python.

Marcadores por Palavra-chave

Use nomes de palavra-chave para a formatação mais legível. Isso também permite reordenar os valores independentemente da lista de argumentos:

name = "John"
age = 30
print("{name} is {age} years old.".format(name=name, age=age))

John is 30 years old.

Você pode desempacotar um dicionário diretamente com **:

person = {"name": "Alice", "city": "London"}
print("{name} lives in {city}.".format(**person))

Alice lives in London.

f-Strings (Python 3.6+)

As f-strings (literais de string formatados) são escritas prefixando a string com f ou F. Qualquer expressão dentro de {} é avaliada em tempo de execução e convertida para uma string. Elas são a opção mais rápida e legível para código Python moderno.

Formatando strings com f-strings em Python

My name is John and I am 30 years old.

Como as chaves podem conter qualquer expressão Python válida, você não está limitado a simples nomes de variáveis:

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")

10 divided by 3 is 3.33

O Especificador de Depuração = (Python 3.8+)

Adicione = após o nome da variável para imprimir tanto o nome da variável quanto seu valor — muito útil para depuração rápida:

val = 42
result = val * 2
print(f"{val=}, {result=}")

val=42, result=84

Especificadores de Formato

Todos os três métodos suportam uma minilinguagem para controlar como os valores são exibidos. A sintaxe dentro de {} para format() e f-strings é:

{[value]:[fill][align][sign][width][grouping][.precision][type]}

Alinhamento e Largura

Use < (esquerda), > (direita) ou ^ (centro) com um número de largura:

name = "John"
print(f"|{name:<10}|")   # left-align in a field of width 10
print(f"|{name:>10}|")   # right-align
print(f"|{name:^10}|")   # center

|John      |
|      John|
|   John   |

Você pode especificar um caractere de preenchimento antes do símbolo de alinhamento:

print(f"|{'hello':*^15}|")  # fill with * and center

|*****hello*****|

Precisão Decimal

pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")   # 2 decimal places
print(f"Pi is approximately {pi:.4f}")   # 4 decimal places

Pi is approximately 3.14
Pi is approximately 3.1416

Formatação de Números

price = 1234567.89
print(f"{price:,.2f}")   # comma as thousands separator
print(f"{price:e}")      # scientific notation

1,234,567.89
1.234568e+06

Para exibir uma proporção como percentual, use o especificador de tipo %:

ratio = 0.853
print(f"{ratio:.1%}")

85.3%

Bases de Inteiros

x = 255
print(f"{x:d}")    # decimal   -> 255
print(f"{x:x}")    # hex lower -> ff
print(f"{x:X}")    # hex upper -> FF
print(f"{x:o}")    # octal     -> 377
print(f"{x:b}")    # binary    -> 11111111

255
ff
FF
377
11111111

Os mesmos especificadores funcionam com str.format():

print("{:b}".format(255))   # 11111111
print("{:x}".format(255))   # ff

Preenchimento com Zeros

Preencha um inteiro com uma largura fixa com zeros à esquerda usando 0 antes da largura:

print(f"{42:010d}")   # zero-pad to 10 digits

0000000042

Escolhendo o Método Certo

As f-strings são o padrão recomendado para todo novo código Python 3. Elas são mais rápidas que str.format() (sem sobrecarga de chamada de método) e mais legíveis que %.

Prática