Python Formatação

Esta é a página de consulta da mini-linguagem de formatação do Python: os códigos que vão depois dos dois-pontos dentro das chaves de uma f-string, como o >10.2f de f"{preco:>10.2f}". Com eles você alinha colunas, fixa as casas decimais, põe separador de milhar, mostra porcentagens, números em binário e datas no formato brasileiro. A explicação passo a passo das f-strings está na aula f-strings: Formatando Textos; aqui ficam as tabelas para consultar.

Pule direto para o que você procura:

• A anatomia de uma especificação
• Largura e alinhamento · Preenchimento e zeros · Sinal
• Casas decimais (precisão) · Separador de milhar
• Os tipos: f, %, e, g, b, o, x, c…
• Largura variável, !r e o = de depuração
• Datas e horas (strftime)
• O jeito brasileiro: 1.234,50
• Os jeitos antigos: .format() e % · Erros comuns

A anatomia de uma especificação

Dentro das chaves vem o valor, dois-pontos e a especificação (em inglês, format spec). Cada parte é opcional, mas a ordem é fixa:

>>> preco = 1234.5
>>> f"{preco:>10.2f}"
'   1234.50'

preco

O valor a formatar (uma variável, uma conta, uma chamada de função).

:

Separa o valor da especificação.

>

Alinhamento: à direita.

10

Largura: o resultado ocupa pelo menos 10 posições.

.2

Precisão: 2 casas decimais.

f

Tipo: número com casas decimais fixas (fixed point).

A ordem completa, como na documentação oficial:

Um exemplo com quase tudo: f"{1234.5:12,.2f}|" (largura 12, separador de milhar, 2 casas) dá '    1,234.50|'.

O mesmo código funciona fora das f-strings, na função format() e no método .format(): format(1234.5, ",.2f") dá '1,234.50'.

Largura e alinhamento

A largura é o número mínimo de posições. Se o valor for menor, o resto vira espaço; se for maior, nada é cortado. Sem alinhamento, textos ficam à esquerda e números à direita.

É assim que se monta uma tabela alinhada na tela:

produtos = [("Pão francês", 0.75, 12), ("Leite", 5.5, 2), ("Queijo minas", 42.9, 1)]

print(f"{'Produto':<14}{'Preço':>9}{'Qtd':>5}{'Total':>10}")
print("-" * 38)
soma = 0
for nome, preco, qtd in produtos:
    total = preco * qtd
    soma = soma + total
    print(f"{nome:<14}{preco:>9.2f}{qtd:>5}{total:>10.2f}")
print("-" * 38)
print(f"{'TOTAL':<28}{soma:>10.2f}")

$ python3 tabela.py
Produto           Preço  Qtd     Total
--------------------------------------
Pão francês        0.75   12      9.00
Leite              5.50    2     11.00
Queijo minas      42.90    1     42.90
--------------------------------------
TOTAL                            62.90

produtos = [("Pão francês", 0.75, 12), ("Leite", 5.5, 2), ("Queijo minas", 42.9, 1)]

print(f"{'Produto':<14}{'Preço':>9}{'Qtd':>5}{'Total':>10}")
print("-" * 38)
soma = 0
for nome, preco, qtd in produtos:
    total = preco * qtd
    soma = soma + total
    print(f"{nome:<14}{preco:>9.2f}{qtd:>5}{total:>10.2f}")
print("-" * 38)
print(f"{'TOTAL':<28}{soma:>10.2f}")

Preenchimento e zeros

Em vez de espaço, o espaço vazio pode ser preenchido com qualquer caractere. Ele vem logo antes do alinhamento, que fica obrigatório.

Sinal

Casas decimais (precisão)

A precisão é um ponto seguido de um número. O que ela faz depende do tipo:

Por que 2.5 vira 2, e não 3? É o "arredondamento do banqueiro", explicado na aula Funções Embutidas (seção do round()).

Separador de milhar

O , e o _ agrupam os algarismos de 3 em 3. O separador sai sempre no padrão americano (vírgula no milhar, ponto nos decimais); para o padrão brasileiro, veja O jeito brasileiro.

Os tipos

A letra do fim diz como o valor vai ser escrito.

Largura variável, !r e o = de depuração

Datas e horas (strftime)

Com datas do módulo datetime (aula Datas e Horas), a especificação é outra: os códigos de %, os mesmos do método .strftime() (string format time, "formatar o tempo como texto"). Os exemplos usam data = datetime(2026, 10, 18, 14, 30, 5), um domingo, às 14h30min05s.

import locale
from datetime import datetime

locale.setlocale(locale.LC_ALL, "")
data = datetime(2026, 10, 18, 14, 30, 5)
print(f"{data:%A, %d de %B de %Y}")
print(f"{data:%x %X}")

$ python3 data_pt.py
domingo, 18 de outubro de 2026
18/10/2026 14:30:05

O jeito brasileiro: 1.234,50

No Brasil, o milhar é separado por ponto e os decimais por vírgula, o contrário do que o ,.2f faz. Há dois caminhos.

1. Trocar os caracteres

Formate no padrão americano e depois troque vírgula por ponto e ponto por vírgula. O método .translate() faz a troca dupla de uma vez (com .replace(), é preciso um caractere intermediário, senão a segunda troca desfaz a primeira):

def brl(valor):
    texto = f"{valor:,.2f}"
    return "R$ " + texto.translate(str.maketrans(",.", ".,"))


print(brl(1234567.891))
print(brl(0.5))
print(brl(-42))

$ python3 brl.py
R$ 1.234.567,89
R$ 0,50
R$ -42,00

2. Usar o idioma do sistema (locale)

Com o locale configurado para português do Brasil (como no computador da Ana), o módulo locale formata do jeito brasileiro, até com o R$:

import locale

locale.setlocale(locale.LC_ALL, "")
valor = 1234567.891
print(locale.currency(valor, grouping=True))
print(locale.format_string("%.2f", valor, grouping=True))
print(f"{1234567:n}")

$ python3 br.py
R$ 1.234.567,89
1.234.567,89
1.234.567

def brl(valor):
    return f"R$ {valor}"


print(brl(1234.5))
print(brl(0.99))

def brl(valor):
    texto = f"{valor:,.2f}"
    return "R$ " + texto.translate(str.maketrans(",.", ".,"))


print(brl(1234.5))
print(brl(0.99))

Os jeitos antigos: .format() e %

Antes das f-strings (Python 3.6), formatava-se de outros dois jeitos, que você ainda encontra em muito código. O .format() usa a mesma mini-linguagem desta página; o % usa códigos parecidos, mas mais limitados.

Erros comuns

A especificação precisa combinar com o tipo do valor. Quando não combina, vem um ValueError (erro de valor). No modo interativo:

$ python3 -q
>>> f"{'Ana':.2f}"
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    f"{'Ana':.2f}"
      ^^^^^^^^^^^
ValueError: Unknown format code 'f' for object of type 'str'
>>> f"{3.5:d}"
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    f"{3.5:d}"
      ^^^^^^^
ValueError: Unknown format code 'd' for object of type 'float'
>>> exit()

Resumo

• A ordem da especificação é fixa: preenchimento, alinhamento, sinal, z, #, 0, largura, agrupamento, precisão, tipo. Ex.: *>+12,.2f.
• Alinhamento: < esquerda, > direita, ^ centro. Textos ficam à esquerda e números à direita por padrão.
• .2f = 2 casas; , ou _ = separador de milhar; .1% = porcentagem; b/o/x = outras bases.
• Datas usam os códigos %: f"{data:%d/%m/%Y}". Nomes de dia e mês saem em inglês sem locale.setlocale().
• Para o formato brasileiro, formate com ,.2f e troque os caracteres com .translate(str.maketrans(",.", ".,")).