Strings em Python
As f-strings são uma melhoria significativa em relação aos métodos tradicionais de formatação de strings em Python. Elas oferecem uma forma mais legível e eficiente de inserir variáveis em strings. Porém, elas não são a única forma para interpolação e formatação de strings em Python.
Antes das f-strings, existiam duas formas principais para interpolação em strings: o módulo operador (%), e o método str.format(). Apesar da introdução das f-strings, essas formas mais antigas de interpolação em strings continuam tendo seu valor. Portanto, neste post, vamos explorar as três técnicas essenciais de manipulação de strings: o operador %, o método format() f-strings. Esses podem parecer conceitos básicos, mas são incrivelmente poderosos e amplamente usados.
Módulo operador (%)
O operador % é um método clássico de formatação de strings em Python e ainda é utilizado. Veja um exemplo simples de como usá-lo:
nome = "Maria"
print("Meu nome é %s" % nome)
# Resultado: Meu nome é Maria
No exemplo acima, o operador % é usado para indicar onde a interpolação deve ocorrer numa string. Note a presença do s depois do operador %. Ele é um especificador de conversão. Especificamente, a letra s informa ao operador que você deseja interpolar o objeto de entrada como uma string. Veja outro exemplo:
idade = 20
print("Eu tenho %s anos" % idade)
# Resultado: Eu tenho 20 anos
Neste exemplo, o operador %s foi utilizado para converter um inteiro (int) em uma string.
Uma das vantagens de se usar especificadores de conversão é que eles oferecem algumas capacidades de formatação, como ilustrado abaixo:
peso = 20.5340
print("O objeto pesa %.2f quilos" % peso)
# Resultado: O objeto pesa 20.53 quilos
Neste exemplo, utilizamos ‘%.2f’ para interpolar e formatar a string resultante. A letra f informa ao operador para converter o objeto interpolado na string para um float. A parte .2 define a precisão a ser utilizada (2 casas decimais).
Se você deseja interpolar mais de um objeto em uma string com o operador %, é necessário colocá-los em uma tupla:
nome = "Pedro"
idade = 20
print("Meu nome é %s e eu tenho %s anos." % (nome, idade))
# Resultado: Meu nome é Pedro e eu tenho 20 anos.
Neste exemplo, a substituição é feita com base na posição das variáveis na tupla. Além da posição, o modulo operador (%) também aceita o uso de dicionários para especificar o local da interpolação:
print("%(nome)s possui %(n)s cachoros" % {"n": 3, "nome": "Bianca"})
# resultado: Bianca possui 3 cachoros
Veja abaixo um exemplo de interpolação e formatação básica utilizando o operador % com duas variáveis:
produto = "carne"
peso = "100"
print("Produto %s\nPeso %6s quilos" % (produto, peso))
# Resultado:
# Produto carne
# Peso 100 quilos
Neste exemplo, usamos ‘%s\n’ para informar ao Python para interpolar o objeto na string na linha abaixo. Já o %6s determina o alinhamento da interpolação 6 posições para a direita.
o método str.format()
Embora o operador % ainda seja utilizado, ele tem limitações consideráveis. Por exemplo, ele não aceita combinar dicionários e tuplas para fazer interpolação. Além disso, sua sintaxe é difícil de ler.
O método str.format() é outra forma popular de interpolação e formatação de strings em Python. Ele foi introduzido para superar as limitações do operador (%).
nome = "Pedro"
idade = 20
print("Meu nome é {} e eu tenho {} anos".format(nome, idade))
# Resultado: Meu nome é Pedro e eu tenho 20 anos
No método str.format() usamos chaves ({}) para indicar os campos de interpolação. Se as chaves estiverem vazias, como no exemplo acima, o Python interpola as variáveis na ordem em que elas aparecem. Se você preferir, pode utilizar índices para indicar a ordem de interpolação. Lembre-se de que os índices em Python começam em 0:
nome = "Pedro"
idade = 20
print("Eu tenho {1} anos e me chamo {0}".format(nome, idade))
# Resultado: Eu tenho 20 anos e me chamo Pedro
Outra maneira de interpolar usando str.format() é incluir os nomes dos argumentos nos campos de substituição e utilizar um dicionário:
print("Eu tenho {idade} anos e me chamo {nome}".format(nome="Pedro", idade=20))
# Resultado: Eu tenho 20 anos e me chamo Pedro
O dicionário pode ser combinado com tuplas para fazer a interpolação:
print("Eu tenho {} anos e me chamo {nome}".format(20, nome="Pedro"))
# Resultado: Eu tenho 20 anos e me chamo Pedro
Nos marcadores de lugar ({}), podemos adicionar especificadores de formatação para formatar o resultado:
peso = 20.5340
print("O objeto pesa {:.2f} quilos".format(peso))
# Resultado: O objeto pesa 20.53 quilos
Neste exemplo, usamos {:.2f} para converter a variável interpolada para um float com precisão de duas casas decimais.
O método str.format() aceita vários especificadores de formatação. Alguns estão ilustrados abaixo:
# :> - alinha o resultado à direita dentro do espaço disponível (use :< para alinhar à esquerda)
print("{:>50}".format("String à direita"))
# resultado: String à direita
# :^ - alinha o resultado no centro dentro do espaço disponível
print("{:^50}".format("String centralizada"))
# resultado: String centralizada
# :=^ - alinha o resultado no centro dentro do espaço disponível e preenche o espaço restante com =
print("{:=^50}".format("String centralizada"))
#resultado: ===============String centralizada================
f-strings
As f-strings foram introduzidas no Python 3.6 para facilitar a formatação e interpolação de strings. Elas são mais rápidas e melhores do que tanto o operador % quanto str.format(). Com as f-strings, podemos incorporar diretamente variáveis e expressões em strings prefixadas com f ou F. Utilizamos chaves ({}) para fazer as incorporações. As f-strings são uma evolução do método str.format(). Elas são muito mais concisas e legíveis. Veja uma comparação abaixo:
print(f"Eu moro no {cidade} anos e me chamo {nome}".format(cidade, nome))
# resultado: Eu moro no Rio de Janeiro anos e me chamo Ana
print(f"Eu moro no {cidade} anos e me chamo {nome}")
# resultado: Eu moro no Rio de Janeiro anos e me chamo Ana
Com as f-strings, podemos interpolar operações aritméticas em strings sem problemas:
x = 20
y = 5
print(f"O resultado é {2 * (x / y)}.")
# resultado: O resultado é 8.0.
Também podemos utilizar f-strings para interpolações em strings multilinhas:
nome = "Caio"
data = "10/02/2026"
print(f"""
Bom dia {nome},
Gostaria de saber sobre sua disponibilidade para nos reunirmos hoje, {data}.
""")
# resultado:
# Bom dia Caio,
# Gostaria de saber sobre sua disponibilidade para nos reunirmos hoje, 10/02/2026.
F-strings aceitam condicionais if else dentro de suas chaves, facilitando muito a execução de inúmeras tarefas. Veja um exemplo abaixo:
nomes = ["Caio", "Ana", "Pedro"]
for nome in nomes:
print(f"""
Bom dia {nome},
Gostaria de saber sobre sua disponibilidade para nos reunirmos no dia {"10/02/2026" if nome == "Caio" else "15/02/2026"}.
""")
# resultados:
# Bom dia Caio,
# Gostaria de saber sobre sua disponibilidade para nos reunirmos no dia 10/02/2026.
# Bom dia Ana,
# Gostaria de saber sobre sua disponibilidade para nos reunirmos no dia 15/02/2026.
# Bom dia Pedro,
# Gostaria de saber sobre sua disponibilidade para nos reunirmos no dia 15/02/2026.
A formatação da precisão de números como floats é simples e direta, veja um exemplo:
valor = 3.14159
print(f"O valor de pi é: {valor:.2f}")
# resultado: O valor de pi é: 3.14
Portanto, as f-strings são um avanço em relação ao módulo operador (%) e ao método format(). Além de mais concisas e simples, elas têm recursos mais poderosos que facilitam muito na automação de várias tarefas cotidianas.
