As f-strings (formatted string literals) são uma das features mais amadas do Python moderno. Introduzidas no Python 3.6 através da PEP 498, elas revolucionaram a forma como concatenamos e formatamos strings na linguagem. Antes delas, os desenvolvedores usavam %-formatting ou o método .format(), ambas soluções funcionais, mas significativamente menos elegantes.
Neste guia completo, você aprenderá desde a sintaxe básica até técnicas avançadas de f-strings, com exemplos práticos que vai usar no dia a dia. Se você está começando agora ou já tem experiência, este artigo vai te ajudar a dominar essa ferramenta indispensável.
O Que São F-Strings e Por Que Usá-las?
Uma f-string é uma string literal prefixada com a letra f ou F, que permite incorporar expressões Python diretamente dentro de chaves {}. O interpretador avalia essas expressões em tempo de execução e as converte automaticamente para string.
A principal vantagem das f-strings é a legibilidade. Compare as três abordagens:
nome = "Ana"
idade = 28
%-formatting (antigo)
print("Meu nome é %s e tenho %d anos." % (nome, idade))
.format()
print("Meu nome é {} e tenho {} anos.".format(nome, idade))
f-string (moderno)
print(f"Meu nome é {nome} e tenho {idade} anos.")
A versão com f-string é claramente mais legível, concisa e intuitiva. Não é à toa que a comunidade Python as adotou tão rapidamente. Segundo a documentação oficial do Python, as f-strings são "expressões avaliadas em tempo de execução, formatadas usando o protocolo __format__".
Sintaxe Básica
A sintaxe fundamental é simples: basta adicionar f antes das aspas e usar {} para incorporar variáveis ou expressões:
nome = "Carlos"
idade = 32
altura = 1.85
print(f"Olá, {nome}. Você tem {idade} anos e {altura}m de altura.")
Saída: Olá, Carlos. Você tem 32 anos e 1.85m de altura.
Você pode usar qualquer tipo de aspas: simples ', duplas ", ou mesmo triplas ''' para strings multilinha:
f'String com aspas simples'
f"String com aspas duplas"
f"""String multilinha
com várias linhas
de texto formatado"""
Expressões Aritméticas
a, b = 10, 3
print(f"{a} + {b} = {a + b}") # 10 + 3 = 13
print(f"{a} / {b} = {a / b:.2f}") # 10 / 3 = 3.33
print(f"{a} elevado a {b} = {a ** b}") # 10 elevado a 3 = 1000
Expressões e Chamadas de Função
Um dos recursos mais poderosos das f-strings é a capacidade de avaliar qualquer expressão Python válida dentro das chaves:
# Chamadas de método
nome = "joão silva"
print(f"Nome formatado: {nome.title()}")
Expressões com listas
numeros = [1, 2, 3, 4, 5]
print(f"Soma: {sum(numeros)}, Média: {sum(numeros)/len(numeros):.1f}")
Acesso a dicionários
usuario = {"nome": "Maria", "cargo": "Engenheira"}
print(f"{usuario['nome']} trabalha como {usuario['cargo']}")
Operador ternário
idade = 17
print(f"{'Maior' if idade >= 18 else 'Menor'} de idade")
O tutorial da Real Python sobre f-strings mostra vários exemplos avançados que expandem ainda mais essas possibilidades.
Formatação de Números
As f-strings brilham quando o assunto é formatar números. Seguindo a especificação de formato do Python, você pode controlar precisamente a saída:
Decimais e Arredondamento
pi = 3.141592653589793
print(f"Pi com 2 casas: {pi:.2f}") # 3.14
print(f"Pi com 4 casas: {pi:.4f}") # 3.1416
print(f"Pi com 6 casas: {pi:.6f}") # 3.141593
Porcentagens
taxa = 0.1785
print(f"Taxa: {taxa:.1%}") # 17.9%
print(f"Taxa: {taxa:.2%}") # 17.85%
Formatação de Moeda
preco = 1499.90
print(f"Preço: R$ {preco:,.2f}") # R$ 1,499.90
print(f"Preço: R$ {preco:010.2f}") # R$ 0001499.90
Números Grandes
populacao = 8_100_000_000
print(f"População: {populacao:,}") # 8,100,000,000
Alinhamento e Preenchimento
# Alinhamento: < (esquerda), > (direita), ^ (centro)
print(f"|{'esquerda':<10}|") # |esquerda |
print(f"|{'direita':>10}|") # | direita|
print(f"|{'centro':^10}|") # | centro |
Preenchimento com caracteres
print(f"{'Python':*^20}") # ***Python****
Trabalhando com Dicionários e Objetos
As f-strings se integram perfeitamente com dicionários e objetos Python. Veja como acessar dados de forma elegante:
# Dicionários
venda = {
"produto": "Notebook",
"quantidade": 3,
"preco_unitario": 4599.90,
"cliente": "Empresa ABC Ltda"
}
total = venda["quantidade"] * venda["preco_unitario"]
print(f"Cliente: {venda['cliente']}")
print(f"Produto: {venda['produto']} x {venda['quantidade']}")
print(f"Total: R$ {total:,.2f}")
Objetos
class Produto:
def init(self, nome, preco, estoque):
self.nome = nome
self.preco = preco
self.estoque = estoque
def str(self):
return f"{self.nome} - R$ {self.preco:.2f} ({self.estoque} und)"
p = Produto("Teclado Mecânico", 289.90, 15)
print(f"{p}") # Usa str automaticamente
Esse padrão é amplamente usado em aplicações reais, especialmente ao gerar relatórios ou renderizar templates no servidor.
Formatação de Datas
Trabalhar com datas em f-strings é extremamente prático. O segredo está em usar os códigos de formatação strftime do Python:
from datetime import datetime
hoje = datetime.now()
print(f"Data: {hoje:%d/%m/%Y}") # 15/05/2026
print(f"Hora: {hoje:%H:%M:%S}") # 14:30:00
print(f"Data completa: {hoje:%A, %d de %B de %Y}")
print(f"Timestamp: {hoje:%Y-%m-%d_%H-%M-%S}") # 2026-05-15_14-30-00
O controle fino sobre a formatação de datas faz das f-strings uma escolha superior ao método tradicional strftime() em muitos casos.
Debugging com F-Strings (Python 3.8+)
O Python 3.8 introduziu um recurso fantástico para debugging através da PEP 536. Ao adicionar = após a expressão, a f-string exibe tanto o nome da variável quanto seu valor:
nome = "Python"
versao = 3.12
ano = 2026
print(f"{nome=}") # nome='Python'
print(f"{versao=}") # versao=3.12
print(f"{ano=}") # ano=2026
Útil para debugging em loops
for i in range(3):
print(f"{i=}, {i**2=}")
i=0, i**2=0
i=1, i**2=1
i=2, i**2=4
Esse recurso substitui com vantagem o velho print("variável =", variavel), tornando o debugging muito mais rápido e limpo.
F-Strings Multilinha
Para textos mais longos, as f-strings com aspas triplas são perfeitas:
nome = "João"
cargo = "Desenvolvedor"
empresa = "TechSolutions"
relatorio = f"""
RELATÓRIO DO FUNCIONÁRIO
Nome: {nome}
Cargo: {cargo}
Empresa: {empresa}
"""
print(relatorio)
Cuidado apenas com a indentação, pois ela é preservada na string final.
F-Strings Aninhadas
Você pode aninhar f-strings dentro de f-strings para formatação dinâmica:
valor = 42.56789
casas = 2
print(f"Valor formatado: {valor:.{casas}f}") # 42.57
Exemplo mais complexo
largura = 10
preenchimento = ""
texto = "Python"
print(f"{texto:{preenchimento}^{largura}}") # Python
Esse recurso é útil quando os parâmetros de formatação vêm de variáveis ou funções.
F-Strings no Python 3.12
O Python 3.12 trouxe melhorias significativas nas f-strings, conforme documentado no What's New in Python 3.12. As principais mudanças incluem:
- Reutilização de aspas: Agora você pode usar o mesmo tipo de aspas dentro das chaves que fora delas
- Expressões aninhadas mais naturais: A sintaxe para expressões complexas foi simplificada
- Melhor performance: O parser de f-strings foi reescrito, tornando-as ainda mais rápidas
# Python 3.12+: aspas compatíveis dentro de expressões
pessoas = [{"nome": "Ana"}, {"nome": "Bob"}]
print(f"Nomes: {[p['nome'] for p in pessoas]}")
# Antes do 3.12, isso gerava SyntaxError!
Armadilhas Comuns
Alguns erros frequentes ao usar f-strings:
1. Chaves Literais: Se precisar exibir chaves literalmente, dobre-as:
print(f"{{Chaves literais}} em f-strings") # {Chaves literais} em f-strings
2. Barra Invertida: Você não pode usar \ dentro da parte de expressão das f-strings:
# ERRADO - SyntaxError
# print(f"Quebra de linha: \n")
CERTO - evalue fora
quebra = "\n"
print(f"Quebra de linha: {quebra}")
3. F-Strings em Logging: Evite f-strings em chamadas de logging. Use formatação com % em vez disso:
import logging
ERRADO - sempre avalia a expressão
logging.warning(f"Erro no usuário {usuario_id}")
CERTO - lazy evaluation
logging.warning("Erro no usuário %s", usuario_id)
Boas Práticas
Seguindo as recomendações da comunidade e da documentação da GeeksforGeeks, aqui estão as melhores práticas:
1. Prefira f-strings para concatenação simples: Elas são mais legíveis e performáticas que concatenação com + ou .format().
2. Evite expressões muito complexas: Se a expressão dentro de {} ficar longa demais, extraia para uma variável primeiro.
3. Use = para debugging temporário: Em vez de prints elaborados, use f"{var=}".
4. Cuidado com dados sensíveis: F-strings em logs podem expor informações confidenciais. Sempre sanitize antes.
# Exemplo de boas práticas
def formatar_usuario(usuario: dict) -> str:
nome = usuario["nome"].title()
salario = usuario["salario"]
bonus = salario * 0.1 if usuario["desempenho"] > 8 else 0
return f"Funcionário: {nome} | Salário: R$ {salario:,.2f} | Bônus: R$ {bonus:,.2f}"
Usando __format__ em Classes Próprias
Você pode personalizar como suas classes são formatadas em f-strings implementando o método especial __format__:
class Moeda:
simbolos = {"BRL": "R$", "USD": "$", "EUR": "€"}
def __init__(self, valor, moeda="BRL"):
self.valor = valor
self.moeda = moeda
def __format__(self, spec):
simb = self.simbolos.get(self.moeda, self.moeda)
if spec == "extenso":
return f"{simb} {self.valor:,.2f} ({self.moeda})"
return f"{simb} {self.valor:{spec}f}" if spec else f"{simb} {self.valor:,.2f}"
dinheiro = Moeda(1250.50, "BRL")
print(f"Saldo: {dinheiro}") # Saldo: R$ 1,250.50
print(f"Saldo: {dinheiro:extenso}") # Saldo: R$ 1,250.50 (BRL)
print(f"Saldo: {dinheiro:.1f}") # Saldo: R$ 1250.5
Esse nível de personalização permite criar formatações específicas para domínios do seu negócio.
Performance: F-Strings vs Alternativas
Estudos de performance mostram que f-strings são consistentemente mais rápidas que as alternativas. Isso ocorre porque elas são avaliadas em tempo de compilação e otimizadas pelo interpretador CPython. Em benchmarks, f-strings são tipicamente 2x mais rápidas que .format() e significativamente mais rápidas que %-formatting.
Para aplicações que processam milhões de strings, como geradores de relatórios ou sistemas de logging de alto volume, usar f-strings em vez de alternativas pode representar uma economia significativa de tempo de CPU.
Conclusão
As f-strings são, sem dúvida, a melhor maneira de trabalhar com strings em Python moderno. Desde sua introdução no Python 3.6, elas evoluíram para incluir debugging integrado (3.8+), melhorias de sintaxe (3.12+) e continuam sendo a escolha preferida da comunidade.
Se você quer dominar Python por completo, recomendo conferir nosso guia completo sobre strings em Python e também o guia para iniciantes em Python, que cobrem desde os fundamentos até tópicos avançados da linguagem.
Comece a usar f-strings hoje mesmo nos seus projetos. A diferença na legibilidade e produtividade do seu código será imediata. Para se aprofundar ainda mais, a documentação oficial do Python é o melhor recurso para consultar todos os detalhes da especificação.