Como usar a interpolação de strings em Python?

[

Python’s F-String para Interpolação e Formatação de Strings

por Joanna Jablonski 18 de outubro de 2023 68 Comentários básicos python

As F-Strings do Python fornecem uma maneira rápida de interpolar e formatar strings. Elas são legíveis, concisas e menos propensas a erros do que as ferramentas tradicionais de interpolação e formatação de strings, como o método .format() e o operador de módulo (%). Uma f-string também é um pouco mais rápida do que essas ferramentas!

Ao final deste tutorial, você saberá por que as f-strings são uma ferramenta tão poderosa que você deve aprender e dominar como desenvolvedor Python.

Neste tutorial, você aprenderá:

• Interpolar valores, objetos e expressões em suas strings usando as f-strings
• Formatar f-strings usando a mini-linguagem de formatação de strings do Python
• Aproveitar alguns recursos interessantes das f-strings no Python 3.12 e posteriores
• Decidir quando usar as ferramentas tradicionais de interpolação em vez das f-strings

Para obter o máximo deste tutorial, você deve estar familiarizado com o tipo de dados string do Python. Também é benéfico ter experiência com outras ferramentas de interpolação de strings, como o operador de módulo (%) e o método .format().

Interpolação e Formatação de Strings Antes do Python 3.6

Antes do Python 3.6, você tinha duas ferramentas principais para interpolar valores, variáveis e expressões dentro de literais de string:

1. O operador de interpolação de string (%), ou operador de módulo
2. O método str.format()

Você terá um lembrete sobre essas duas ferramentas de interpolação de string nas seções a seguir. Você também aprenderá sobre a formatação de strings c

O Operador de Módulo, %

O operador de módulo (%) permite que você insira valores em uma string usando especificadores de formato. Aqui está um exemplo:

name = "Alice"
age = 25

message = "Meu nome é %s e eu tenho %d anos." % (name, age)
print(message)

Neste exemplo, %s é um especificador de formato para uma string, enquanto %d é um especificador de formato para um número inteiro. Os valores name e age são fornecidos como uma tupla na ordem em que devem ser interpolados na string.

O Método str.format()

O método str.format() é uma alternativa ao operador de módulo (%) e oferece mais flexibilidade na formatação de valores em strings. Veja um exemplo:

name = "Alice"
age = 25

message = "Meu nome é {} e eu tenho {} anos.".format(name, age)
print(message)

Neste exemplo, os espaços reservados {} na string são substituídos pelos valores name e age passados para o método .format().

Fazendo Interpolação de String com F-Strings em Python

A partir do Python 3.6, você pode usar f-strings para fazer interpolação de string. As f-strings são prefixadas pelo caractere f e permitem que você inclua expressões Python dentro de chaves {} em uma string. Aqui está um exemplo:

name = "Alice"
age = 25

message = f"Meu nome é {name} e eu tenho {age} anos."
print(message)

Neste exemplo, as expressões name eage são avaliadas e interpoladas diretamente nas chaves {} na string. O resultado final é a string “Meu nome é Alice e eu tenho 25 anos.”.

Interpolando Valores e Objetos em F-Strings

Você pode interpolar diferentes tipos de valores e objetos em f-strings. Por exemplo:

name = "Alice"
age = 25
height = 1.65

message = f"Meu nome é {name}, eu tenho {age} anos e minha altura é {height:.2f} metros."
print(message)

Neste exemplo, {height:.2f} é um exemplo de formatação de número de ponto flutuante. A expressão {height} é formatada como um número de ponto flutuante com duas casas decimais.

Incorporando Expressões em F-Strings

Além de interpolar valores e objetos, as f-strings também permitem incorporar expressões Python diretamente em seus literais de strings. Aqui está um exemplo:

name = "Alice"
age = 25

message = f"Daqui a cinco anos, eu vou ter {age + 5} anos."
print(message)

Neste exemplo, a expressão age + 5 é avaliada e interpolada diretamente na string. O resultado final é a string “Daqui a cinco anos, eu vou ter 30 anos.”.

Formatando Strings com F-String do Python

As f-strings também permitem que você faça formatação adicional nas expressões interpoladas usando a mini-linguagem de formatação de strings do Python. Aqui está um exemplo:

name = "Alice"
age = 25

message = f"Meu nome é {name.upper():>10} e eu tenho {age + 5:<5d} anos."
print(message)

Neste exemplo, a formatação name.upper():>10 faz com que o valor name seja convertido para maiúsculas e justificado à direita em um campo de tamanho 10. A formatação age + 5:<5d adiciona 5 ao valor age e justifica à esquerda em um campo de tamanho 5.

Outros Recursos Relevantes das F-Strings

As f-strings têm alguns recursos adicionais que podem ser úteis em determinadas situações.

Usando Representações de String de Objetos em F-Strings

Você pode usar as representações de string de objetos diretamente em f-strings. Por exemplo:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person: {self.name}"

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

person = Person("Alice", 25)

message = f"O objeto person é {person}."
print(message)

Neste exemplo, a expressão {person} na f-string usa o método __str__ do objeto person para obter sua representação em string.

Expressões Autoexplicativas para Depuração

As f-strings permitem que você insira expressões autoexplicativas dentro da própria f-string para ajudar na depuração de código. Por exemplo:

x = 10
y = 5

result = f"A soma de {x} e {y} é {x + y}."  # Output: A soma de 10 e 5 é 15.

Neste exemplo, a f-string inclui uma expressão {x + y} que calcula a soma de x e y.

Comparando Desempenho: F-String versus Ferramentas de Formatação Tradicionais

As f-strings geralmente são mais rápidas do que as ferramentas de interpolação e formatação de strings tradicionais, como o método .format() e o operador de módulo (%). Aqui está um exemplo que compara o desempenho das f-strings com o método .format():

import timeit

name = "Alice"
age = 25

format_time = timeit.timeit(lambda: "Meu nome é {} e eu tenho {} anos.".format(name, age), number=1000000)
fstring_time = timeit.timeit(lambda: f"Meu nome é {name} e eu tenho {age} anos.", number=1000000)

print(f"format(): {format_time}")
print(f"f-string: {fstring_time}")

Neste exemplo, o tempo de execução do método .format() é comparado com o tempo de execução das f-strings. O número de vezes que cada expressão é executada é definido pelo argumento number da função timeit.timeit().

Atualizando F-Strings: Python 3.12 e Além

A partir do Python 3.12, as f-strings ganham alguns recursos adicionais para aprimorar ainda mais a maneira como você pode usar e formatar suas strings.

Usando Aspas

Em Python 3.12 e posteriores, você pode usar aspas dentro de f-strings sem a necessidade de escape. Aqui está um exemplo:

name = "Alice"

message = f"A string contém a palavra 'Alice': {name in 'Hello, Alice!'}"
print(message)

Neste exemplo, a expressão {name in 'Hello, Alice!'} é interpolada na f-string, e as aspas em torno da palavra 'Alice' não precisam ser escapadas.

Usando Barras Invertidas

Em Python 3.12 e posteriores, f-strings podem usar barras invertidas para escapar caracteres especiais. Por exemplo:

path = r"C:\Program Files"

message = f"O diretório de instalação é '{path}'"
print(message)

Neste exemplo, a string path é interpolada na f-string, e a barra invertida é escapada para que seja exibida corretamente na saída.

Escrevendo Comentários Inline

Em Python 3.12 e posteriores, você pode incluir comentários inline dentro de suas f-strings. Aqui está um exemplo:

name = "Alice"
age = 25

message = f"Meu nome é {name=} e eu tenho {age=} anos."
print(message)

Neste exemplo, os comentários inline {name=} e {age=} dentro da f-string fornecem informações adicionais sobre o valor de name e age.

Decifrando Mensagens de Erro de F-String

Em Python 3.12 e posteriores, as mensagens de erro das f-strings são aprimoradas para fornecer informações mais úteis sobre o problema. Por exemplo:

name = "Alice"

# Aqui ocorrerá um erro de tipo
message = f"Meu nome é {name:.2f}."
print(message)

Neste exemplo, a formatação :.2f é usada com a expressão {name} na f-string. No entanto, name é uma string, e não é possível formatar uma string como um número de ponto flutuante. A mensagem de erro melhorada informa sobre esse problema específico.

Usando Ferramentas de Formatação de Strings Tradicionais em Vez das F-Strings

Embora as f-strings sejam uma ferramenta poderosa para interpolação e formatação de strings, pode haver casos em que as ferramentas tradicionais são mais adequadas. Aqui estão alguns exemplos:

Interpolação de Dicionário

Se você está interpolando valores de um dicionário, pode ser mais conveniente usar o método .format_map(). Veja um exemplo:

person = {"name": "Alice", "age": 25}

message = "Meu nome é {name} e eu tenho {age} anos.".format_map(person)
print(message)

Neste exemplo, o método .format_map() é usado para aplicar os valores do dicionário person à string.

Avaliação Preguiçosa em Registros de Log

Se você está fazendo avaliação preguiçosa de expressões em registros de log, as f-strings podem não ser a melhor escolha. Nesses casos, ferramentas como o método .format() ou funções lambda em conjunto com estratégias de log podem ser mais adequadas.

Consultas de Banco de Dados SQL

Quando você está fazendo consultas em bancos de dados SQL, especialmente consultas extensas ou complexas, pode ser preferível usar ferramentas de formatação SQL específicas ou bibliotecas ORM.

Internacionalização e Localização

Se você está trabalhando com internacionalização e localização, existem bibliotecas específicas que fornecem suporte completo para formatação de strings em diferentes idiomas e culturas.

Convertendo Strings Antigas para F-Strings Automaticamente

Se você tem um código existente que usa uma forma diferente de interpolação de string, é possível automatizar sua conversão para f-strings usando ferramentas como o 2to3 ou futurize.

Conclusões Principais

As f-strings são uma adição poderosa ao Python, permitindo que você faça interpolação e formatação de strings de maneira eficiente e concisa. Elas oferecem recursos flexíveis que ajudam na legibilidade e manutenção de seu código.

Ao usar f-strings, você tem a capacidade de interpolação e formatação de strings na ponta dos dedos, tornando o processo mais rápido e menos propenso a erros. Além disso, as f-strings são mais rápidas do que as ferramentas tradicionais de formatação de strings.

Agora que você entende o poder das f-strings, aproveite ao máximo essa ferramenta em seus projetos Python para tornar suas strings mais legíveis e eficientes.