Interpolação de String em Python: Um Guia para Iniciantes

Suponha que você queira exibir o nome e a profissão de uma pessoa. Você poderia escrever um programa simples da seguinte forma.

# Definir variáveis
name = 'Mark'
profession = 'Astronaut'
age = 7


# Exibir informações
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

Essa abordagem carece de concisão e legibilidade. Felizmente, a interpolação de strings oferece uma solução melhor. Ela permite que variáveis, expressões ou saídas de funções sejam inseridas diretamente em uma string, tornando a manipulação de strings dinâmica e eliminando a necessidade de concatenação manual.

Usando uma abordagem de interpolação de strings, poderíamos reescrever o código da seguinte forma.

# Definir variáveis
name = 'Mark'
profession = 'Astronaut'
age = 7


# Exibir informações
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

A versão com interpolação de strings permite embutir expressões diretamente dentro da string sem o uso de concatenações complicadas. Como você pode ver, é uma abordagem muito mais limpa.

Interpolação Básica de Strings em Python

Existem várias técnicas diferentes de interpolação de strings disponíveis em Python. O método mais comumente recomendado são os literais de string formatados, também conhecidos como f-strings, que estão disponíveis desde o Python 3.6.

Outro método, comumente visto em códigos mais antigos que o Python 3.6, é o método .format(). Embora este método seja mais verboso do que as f-strings, ocasionalmente possui vantagens (detalhes abaixo).

Finalmente, você pode encontrar % formatação no estilo de legado.

Usando f-strings (Python 3.6+)

f-strings (literais de string formatados) são uma maneira poderosa e concisa de formatar strings em Python. Foram introduzidos no Python 3.6 e fornecem uma maneira legível e eficiente de inserir variáveis, expressões e chamadas de função diretamente em strings.

Um simples exemplo da sintaxe básica de uma f-string é o seguinte.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)

   My name is Mark.

Neste código, a variável output_string é atribuída a uma f-string. O f prefixo antes da aspas indica que a string suporta expressões incorporadas. A variável name é avaliada e o seu valor é inserido na string, resultando na saída: "Meu nome é Mark."

Não apenas valores de variáveis, mas também cálculos ou expressões podem ser inseridos em f-strings. Considere este exemplo.

import math


a = 3.0
b = 4.0


# Use interpolação de string para a fórmula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.

A expressão math.sqrt(a ** 2 + b ** 2) é avaliada diretamente dentro da string, eliminando a necessidade de calcular o valor separadamente antes de inseri-lo na string.

Usando o método .format()

Assim como as f-strings, o .format() método permite inserir variáveis e expressões em uma string. A sintaxe básica do .format() método é a seguinte.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)

   My name is Mark.

As chaves {} servem como marcadores de posição, sinalizando que o valor de uma variável será inserido na string nessa posição. O valor específico da variável inserida no marcador de posição é determinado pelo argumento fornecido ao método .format().

Argumentos posicionais

O que acontece se você precisar de vários marcadores de posição para múltiplas variáveis? Considere o código a seguir.

name = 'Mark'
age = 7


# Os marcadores de posição são preenchidos na ordem dos argumentos
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

Neste exemplo, são necessárias duas variáveis, name e age. Consequentemente, a string inclui dois espaços reservados, e as variáveis são inseridas na mesma ordem em que aparecem no .format(). Esses argumentos são conhecidos como *posicionais* argumentos porque sua colocação na string é determinada por sua posição na lista de argumentos do método.

Índice e espaços reservados nomeados

Como uma variação da ideia de espaços reservados, considere este exemplo.

name = 'Mark'
age = 7


# Imprimir idade duas vezes
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Aqui, reutilizamos o valor da variável age duas vezes. Incluir a mesma variável múltiplas vezes assim é desajeitado e prejudica a legibilidade. Existe uma maneira de reutilizar uma variável em uma string formatada com o .format() sem repeti-la? Sim, existe, usando os chamados *placeholders indexados*.

name = 'Mark'
age = 7


# Use placeholders indexados
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Neste exemplo, definimos explicitamente a ordem das variáveis dentro das chaves, seguindo a indexação baseada em zero do Python. Além disso, reutilizamos a variável no índice 1 em vez de repeti-la.

Como alternativa à indexação posicional, você também pode usar argumentos nomeados, onde cada argumento recebe um nome.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))

   My name is Mark and I am 7 years old.

O argumento nomeado é avaliado dentro das chaves que especificam o seu nome. Como resultado, o {name} espaço reservado é substituído pelo valor "Mark", e o {age} espaço reservado é substituído por 30.

Usando o operador %

O método final para interpolação de strings é o % operador. Ele funciona de forma semelhante ao comando printf() em C. Seu uso é obsoleto e fortemente desencorajado em favor de f-strings ou do método .format(). É mencionado aqui porque você pode encontrá-lo em bases de código legadas.

O formato básico para o operador % é: "string de formato" % valores. A string de formato contém espaços reservados, como %s para strings, que são substituídos pelos valores. Por exemplo, o seguinte exemplo imprime “Olá, Mark.”

'Hello %s' % 'Mark'

   'Hello Mark'

Outros especificadores de formato comuns são mostrados na tabela a seguir.

O operador % tem muitas limitações. Por um lado, é menos legível do que as f-strings. Considere o seguinte código.

name = "Alice"
age = 30
height = 5.6


# O operador % é difícil de escanear
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Este código é claro à primeira vista? Provavelmente não. Há muita análise visual de um lado para o outro entre o espaço reservado e as variáveis que preenchem as lacunas. É fácil ficar confuso (ou tonto) com toda essa leitura de um lado para o outro.

Agora, considere um código equivalente usando f-strings.

# Isso é muito mais limpo
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Nenhuma leitura e nenhuma string de formatação obscura são necessárias. O código é limpo, fácil de entender e fácil de escrever. Você pode aprender outras dicas para escrever código claro e otimizado com a trilha de habilidades de Programação em Python da DataCamp.

Técnicas Avançadas de Interpolação de Strings em Python

Agora que entendemos o básico da interpolação de strings em Python, vamos olhar para alguns usos mais avançados.

Interpolação de strings multilinha em Python

As f-strings também podem ser usadas para conteúdo multilinha utilizando o sinalizador f com aspas triplas (simples ou duplas). O texto pode ser escrito em várias linhas, e aparecerá na saída exatamente como formatado.

name = 'Mark'
profession = 'Astronaut'
age = 7


# Este é um exemplo de uma string multilinha
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

As strings multilinhas também podem ser criadas usando o método .format().

name = 'Mark'
profession = 'Astronaut'
age = 7


# Este é um exemplo de string multilinha com .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Casos de uso para interpolação de strings multilinhas

Por que você gostaria de usar interpolação de strings multilinhas? Existem muitos usos para interpolação de strings multilinhas. Aqui estão alguns casos de uso:

• Gerar emails ou mensagens multilinhas
• Registro e depuração
• Gerar consultas SQL dinamicamente

Gerar emails ou mensagens multilinhas

Suponha que você esteja enviando uma carta padrão para muitos convidados para uma conferência de tecnologia.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event Team

Com f-strings, criar uma carta padrão é simples e eficiente. Para alterar o nome, evento ou data, basta alterá-los nas variáveis e a string muda automaticamente.

Registro e depuração

Strings multilinhas são úteis para imprimir mensagens de erro nos logs.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.

Este método mantém as mensagens de log estruturadas e facilita a depuração com logs formatados corretamente.

Gerar consultas SQL dinamicamente

Consultas SQL podem ser construídas dinamicamente usando strings multilinhas.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

Este método torna as consultas SQL legíveis e mantém a indentação. Além disso, elimina a necessidade de usar + para a concatenação de strings.

Outros casos de uso incluem:

• Escrita de contratos formatados
• Criação de documentos Markdown ou $\LaTeX$
• Modelos HTML/XML multilinhas
• Gerando respostas de API ou texto semelhante a JSON

Vantagens da interpolação de strings multilinha

Como podemos ver, há várias vantagens na interpolação de strings multilinha.

• A interpolação de strings preserva a formatação sem precisar do caractere de escape \n. 
• A interpolação de strings melhora a legibilidade em comparação com a formatação em uma única linha. 
• A interpolação de strings reduz a desordem ao trabalhar com texto estruturado (por exemplo, logs, consultas, relatórios). 
• A interpolação de strings permite a geração dinâmica de texto sem quebrar a indentação.

Formatando números e valores especiais

Para controlar o número de casas decimais exibidas usando uma f-string, use a sintaxe: f'{value:.nf}', onde value é o número de ponto flutuante, n é o número de casas decimais, e f (o que vem depois do .) representa a formatação de ponto flutuante.

Para ilustrar, o seguinte código imprime $\pi$ em diferentes casas decimais.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

A formatação com o método .format() é semelhante.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

Você pode usar uma f-string para formatar porcentagens usando a sintaxe :.nf combinada com %, onde n é o número de casas decimais.

score = 0.875
print(f"Success rate: {score:.2%}")

   Success rate: 87.50%

Você pode usar um f-string para formatar moeda utilizando o :, para separadores de milhar e .nf para controlar casas decimais. Você também pode incluir um símbolo de moeda como $, €, ou £ diretamente na string.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

Usando f-strings com dicionários e listas

Para usar f-strings com um dicionário em Python, acesse os valores do dicionário dentro das chaves usando a notação de colchetes (dict[‘key’]) ou descompactando o dicionário com **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")

   My name is Alice, I am 30 years old, and I live in New York.

Em vez de acessar cada chave manualmente, você pode descompactar o dicionário em um f-string da seguinte forma.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))

   My name is Alice and I am 7 years old.

Para evitar um erro por chaves ausentes, use get() para acesso ao dicionário.

person = {"name": "Alice"}


# Erro: chave 'cidade' está ausente
print(f"City: {person['city']}") 

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Erro: chave 'cidade' está ausente

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'

print(f"City: {person.get('city', 'Not specified')}")

   City: Not specified

Prós e Contras dos Métodos de Interpolação de Strings

Como vimos, as f-strings e o método .format() são ambos métodos úteis para interpolação de strings. Vamos analisar uma comparação dos prós e contras de cada método.

Quando você deve usar .format() em vez de f-strings?

Armadilhas Comuns e Melhores Práticas

Aqui você pode encontrar alguns métodos de solução de problemas e dicas principais para usar a interpolação de strings em Python.

Avoiding syntax errors with curly braces

Há muitos erros de sintaxe que se podem cometer ao usar interpolação de strings envolvendo chaves.

• Assegure-se de que cada { tem uma correspondência }

print('Hello, my name is {name!'}

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('

Felizmente, o erro é simples e a correção é fácil.

• Utilize {{ e }} para exibir {} literais

O que acontece se você quiser imprimir chaves dentro de uma string interpolada? Qualquer coisa dentro de chaves será (tentada a ser) avaliada.

print(f'Set notation: {a, b, c}')

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not defined

O Python interpreta a, b, c dentro das chaves como uma tupla, tentando encontrar um valor associado a a. Como nenhuma variável existe, ele gera um KeyError. A correção é usar chaves duplas {{}}.

print("Set notation: {{a, b, c}}")

Notação de conjunto: {{a, b, c}}

Comparação de desempenho: f-strings vs .format()

Vamos comparar o desempenho de f-strings e .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Medir o desempenho de f-string
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Medir o desempenho de .format()
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Medir o desempenho de f-string com expressões
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Medir o desempenho de .format() com expressões
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Imprimir resultados
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Como pode ver, do ponto de vista da eficiência, deve-se preferir f-strings ao .format().

Práticas recomendadas para interpolação de strings limpa e legível

Para garantir que a formatação de suas strings seja clara, eficiente e de fácil manutenção, siga estas práticas recomendadas ao usar strings interpoladas.

• Preferir f-strings para legibilidade (Python 3.6+)

# Recomendado
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Não recomendado (Menos legível)
print("My name is {} and I am {} years old.".format(name, age))


# Evite usar formatação % (Desatualizado)
print("My name is %s and I am %d years old." % (name, age))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Utilize marcadores nomeados para clareza

# Marcadores nomeados (legíveis)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Usando índices em .format() (menos legível)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Mantenha as strings multilinhas legíveis.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  

• Use f-strings no Logging para Melhor Debugging

O Python 3.8 e posterior suporta = para debugging em f-strings.

value = 42


# Output: value = 42
print(f"{value = }") 

   value = 42

Conclusão

A interpolação de strings é um recurso poderoso em Python que torna a formatação de strings mais limpa, legível e eficiente. Entre os métodos disponíveis, as f-strings são a abordagem mais moderna e recomendada, oferecendo melhor desempenho, clareza e flexibilidade em relação a métodos mais antigos como .format() e % de formatação. 

Ao seguir as melhores práticas, como usar espaços reservados nomeados, controlar a precisão decimal, alinhar o texto para legibilidade e lidar com chaves de dicionário ausentes de forma elegante, você pode escrever formatação de string limpa, profissional e sustentável em Python.

Seja para gerar relatórios formatados, mensagens multilinhas ou saídas de dados estruturados, as f-strings oferecem uma maneira simples e poderosa de integrar variáveis e expressões de forma transparente. Adotar as f-strings não apenas melhorará a qualidade do seu código, mas também aprimorará sua eficiência.

Para mais informações sobre interpolação de strings em Python, confira os recursos da DataCamp:

• Formatação de f-string em Python tutorial
• Python Anexar String: 6 Técnicas Essenciais de Concatenação
• Programação em Python trilha de habilidades
• Fundamentos de Python trilha de habilidades
• Introdução à Ciência de Dados em Python curso