Interpolação de cadeias de caracteres Python: Um guia para iniciantes

Suponha que você queira gerar o nome e a profissão de uma pessoa. Você poderia escrever um programa simples como este.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
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. Ele permite que variáveis, expressões ou saídas de funções sejam inseridas diretamente em uma cadeia de caracteres, tornando a manipulação de cadeias de caracteres dinâmica e eliminando a necessidade de concatenação manual.

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

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
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 string permite incorporar expressões diretamente dentro da string sem o uso de concatenações confusas. Como você pode ver, é uma abordagem muito mais limpa.

Interpolação básica de strings em Python

Há várias técnicas diferentes de interpolação de strings disponíveis no 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 anteriores ao Python 3.6, é o método .format(). Embora esse método seja mais prolixo do que o f-strings, ele ocasionalmente tem vantagens (detalhes abaixo).

Por fim, você pode encontrar %-formatação de estilo em código legado.

Usando f-strings (Python 3.6+)

f-strings (literais de strings formatadas) são uma maneira poderosa e concisa de formatar strings em Python. Elas foram introduzidas no Python 3.6 e oferecem uma maneira legível e eficiente de inserir variáveis, expressões e chamadas de função diretamente em cadeias de caracteres.

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

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

   My name is Mark.

Nesse código, a variável output_string recebe a atribuição de uma string f. O prefixo f antes da aspa de abertura indica que a string suporta expressões incorporadas. A variável name é avaliada e seu valor é inserido na string, resultando na saída : "My name is 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 string interpolation for the formula
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 na cadeia de caracteres, eliminando a necessidade de computar o valor separadamente antes de inseri-lo na cadeia.

Usando o método .format()

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

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

   My name is Mark.

Os colchetes {} servem como espaço reservado, indicando que o valor de uma variável será inserido na cadeia de caracteres nessa posição. O valor da variável específica inserida no espaço reservado é determinado pelo argumento fornecido ao método .format().

Argumentos posicionais

O que acontece se você precisar de vários espaços reservados para várias variáveis? Considere o código a seguir.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
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, você precisa de duas variáveis: name e age. Consequentemente, a cadeia de caracteres inclui dois espaços reservados e as variáveis são inseridas na mesma ordem em que aparecem no método .format(). Esses argumentos são conhecidos como *positional* arguments porque seu posicionamento na string é determinado por sua posição na lista de argumentos do método.

Espaços reservados indexados e nomeados

Como uma variação da ideia do espaço reservado, considere este exemplo.

name = 'Mark'
age = 7


# Print age twice
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 várias vezes dessa forma é complicado e prejudica a legibilidade. Existe uma maneira de reutilizar uma variável em uma string formatada com o método .format() sem repeti-la? Sim, você pode, usando os chamados *indexed placeholders*.

name = 'Mark'
age = 7


# Use indexed placeholders
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 entre colchetes, 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, em que 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 dos colchetes que especificam seu nome. Como resultado, o espaço reservado {name} é substituído pelo valor "Mark", e o espaço reservado {age} é substituído por 30.

Usando o operador %

O método final para interpolação de strings é o operador%. 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(). Ele é mencionado aqui porque você pode encontrá-lo em bases de código legadas.

O formato básico do operador % é: "format string" % values. A string de formato contém espaços reservados, como %s para strings, que são substituídos por valores. Por exemplo, o exemplo a seguir imprime "Hello, 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, ele é menos legível do que as f-strings. Considere o código a seguir.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
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.

Esse código está claro à primeira vista? Provavelmente não. Há muita análise visual entre o espaço reservado e as variáveis que preenchem os espaços em branco. É fácil você se confundir (ou ficar tonto) com toda essa varredura para frente e para trás.

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

# This is much cleaner
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.

Você não precisa fazer varredura nem usar strings de formatação obscuras. O código é limpo, fácil de entender e fácil de escrever. Você pode aprender outras dicas para escrever códigos claros e otimizados com ocurso de habilidades de programação em Python do DataCamp. 

Técnicas avançadas de interpolação de strings em Python

Agora que você já entendeu os conceitos básicos da interpolação de strings em Python, vamos examinar alguns usos mais avançados. 

Interpolação de strings de várias linhas em Python

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

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


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

 As cadeias de caracteres com várias linhas também podem ser criadas usando o método .format().

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


# This is a multiline string with .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 de várias linhas

Por que você gostaria de usar a interpolação de strings de várias linhas? Há muitos usos para a interpolação de strings de várias linhas. Aqui estão alguns casos de uso:

• Geração de e-mails ou mensagens de várias linhas
• Registro e depuração
• Geração de consultas SQL de forma dinâmica

Geração de e-mails ou mensagens de várias linhas

Suponha que você esteja enviando uma carta de formulário para muitos convidados de 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 as f-strings, a criação de uma carta de formulário é simples e eficiente. Para alterar o nome, o evento ou a data, basta alterá-los nas variáveis e a string será alterada automaticamente.

Registro e depuração

As cadeias de caracteres de várias linhas são úteis para imprimir mensagens de erro em registros.

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.

Esse método mantém as mensagens de registro estruturadas e facilita a depuração com registros devidamente formatados.

Geração de consultas SQL de forma dinâmica

As consultas SQL podem ser criadas dinamicamente usando cadeias de caracteres de várias linhas.

table = 'users'
column = 'email'
value = 'alice@example.com'


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


print(query)

   SELECT *

   FROM users

   WHERE email = 'alice@example.com';

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

Outros casos de uso incluem:

• Redação de contratos formatados
• Criando Markdown ou $\LaTeX$ documentos
• Modelos HTML/XML de várias linhas
• Geração de respostas de API ou texto semelhante a JSON

Vantagens da interpolação de strings de várias linhas

Como você pode ver, há várias vantagens na interpolação de strings de várias linhas.

• A interpolação de strings preserva a formatação sem a necessidade do caractere de escape \n.
• A interpolação de strings melhora a legibilidade em comparação com a formatação de linha única. 
• 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. 

Formatação de números e valores especiais

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

Para ilustrar, o código a seguir gera $\pi$ com 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 string f para formatar porcentagens usando a sintaxe :.nf combinada com %, em que n é o número de casas decimais.

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

   Success rate: 87.50%

Você pode usar uma string f para formatar a moeda usando :, para separadores de milhares e .nf para controlar as casas decimais. Você também pode incluir um símbolo de moeda, como $, € ou £, diretamente na cadeia de caracteres.

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

Uso de f-strings com dicionários e listas

Para usar f-strings com um dicionário em Python, acesse os valores do dicionário dentro dos colchetes 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 uma string f 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 falta de chaves, use get() para acessar o dicionário.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") 

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Error: key 'city' is missing

   ----> 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 cadeias de caracteres

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

Quando você deve usar .format() sobre as cordas f?

Armadilhas comuns e práticas recomendadas

A seguir, você encontrará alguns métodos de solução de problemas e as principais dicas para usar a interpolação de cadeia de caracteres do Python. 

Como evitar erros de sintaxe com chaves

Há muitos erros de sintaxe que você pode cometer ao usar a interpolação de strings envolvendo chaves.

• Certifique-se de que cada { tenha um } correspondente.

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.

• Use {{ e }} para exibir o literal {}

O que acontece se você quiser imprimir chaves em uma cadeia de caracteres interpolada? Qualquer coisa dentro de colchetes será (tentará 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 essa variável não existe, você recebe um KeyError. A correção é usar colchetes duplos {{}}.

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 das cadeias de caracteres f e .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


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


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


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
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 você pode ver, do ponto de vista da eficiência, deve-se preferir as cordas f a .format().

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

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

• Prefira f-strings para facilitar a leitura (Python 3.6+)

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


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
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.

• Use marcadores de posição nomeados para maior clareza

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
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 cadeias de caracteres de várias linhas 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 registro para melhorar a depuração

O Python 3.8 e posteriores oferecem suporte a = para depuração em f-strings.

value = 42


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

   value = 42

Conclusão

A interpolação de strings é um recurso avançado do Python que torna a formatação de strings mais limpa, mais legível e mais 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 % formatting .

Seguindo as práticas recomendadas, como o uso de placeholders nomeados, o controle da precisão decimal, o alinhamento do texto para facilitar a leitura e o tratamento de chaves de dicionário ausentes, você pode escrever uma formatação de cadeia de caracteres limpa, profissional e de fácil manutenção em Python. 

Independentemente de você estar gerando relatórios formatados, mensagens de várias linhas ou saídas de dados estruturados, as f-strings oferecem uma maneira simples, mas poderosa, de integrar variáveis e expressões sem problemas. A adoção de f-strings não apenas melhorará a qualidade do seu código, mas também aumentará sua eficiência. 

Para obter mais informações sobre interpolação de strings em Python, consulte os recursos do DataCamp:

• Formatação de f-string em Python tutorial
• Python Append String: 6 Técnicas essenciais de concatenação
• Programação Python trilha de habilidades
• Fundamentos de Python trilha de habilidades
• Introdução à ciência de dados em Python curso