Domine as f-strings do Python, a maneira mais elegante de lidar com a formatação de strings em seu código. Este guia abrange tudo, desde a sintaxe básica até as técnicas avançadas. Você aprenderá a escrever códigos mais limpos e de melhor manutenção com exemplos do mundo real.
As f-strings do Python representam uma maneira eficiente e intuitiva de formatar strings. As f-strings mudaram a forma como os desenvolvedores lidam com a formatação de strings no Python, tornando o código mais legível e de fácil manutenção do que nunca.
Imagem do autor
F-strings são literais de string prefixados com 'f' ou 'F' que contêm expressões dentro de chaves {}. Essas expressões são avaliadas em tempo de execução e, em seguida, formatadas usando o protocolo __format__. Diferentemente dos métodos tradicionais de formatação de strings, as f-strings oferecem uma maneira mais direta e legível de incorporar expressões Python diretamente em literais de strings.
Considere este cenário comum em que você precisa formatar uma simples saudação:
name ="Alice"
age =25# Using % operator (old style)print("My name is %s and I'm %d years old"%(name, age))# Using str.format()print("My name is {} and I'm {} years old".format(name, age))# Using f-stringprint(f"My name is {name} and I'm {age} years old")Tecnologia
Você percebeu como as f-strings eliminam a sobrecarga cognitiva de combinar variáveis com espaços reservados? Essa clareza se torna ainda mais valiosa quando você lida com a formatação de dados complexos em aplicativos do mundo real, conforme mostrado abaixo:
price =49.99
quantity =3print(f"Total cost: ${price * quantity:.2f}")# Calculations right in the string!Tecnologia
Além da legibilidade, as f-strings se destacam pelo desempenho. Elas são mais rápidas do que %-formatting e str.format() porque são avaliadas em tempo de execução em vez de exigir várias operações com strings. O Python otimiza a avaliação de strings f, tornando-as uma opção eficiente para a formatação de strings.
Desde o Python 3.8, as f-strings se tornaram ainda mais úteis para depuração com a adição do especificador '='. Esse recurso prático exibe os nomes das variáveis e seus valores em uma única linha:
x =10
y =20print(f"{x=}, {y=}")# Output: x=10, y=20Tecnologia
Neste artigo, daremos uma olhada nas f-strings, abordando tudo, desde a sintaxe básica até as técnicas avançadas de formatação. Você verá como avaliar expressões, formatar números e datas, lidar com cadeias de caracteres de várias linhas e aplicar práticas recomendadas em seu código.
Sintaxe básica das f-Strings do Python
As strings F oferecem uma maneira moderna e intuitiva de formatar strings em Python usando um prefixo simples e uma sintaxe de expressão. Vamos começar com os fundamentos da criação de cordas f.
Criando uma f-String
Para criar uma string f, basta adicionar a letra "f" ou "F" antes do literal da string. Os prefixos em letras minúsculas e maiúsculas funcionam de forma idêntica. É puramente uma questão de preferência de estilo de codificação. Veja como podemos criar cordas f básicas:
# Both 'f' and 'F' prefixes work exactly the same way message1 = f”This is an f-string”message2 = F”This is also an f-string”# Without the prefix, it's just a regular string regular_string = “This is a normal string”Tecnologia
O verdadeiro poder das f-strings vem de sua capacidade de incorporar expressões dentro de chaves {}. Essas expressões são avaliadas em tempo de execução e seus valores são inseridos na string. Vamos ver isso em ação, conforme mostrado abaixo:
# You can put the expression directly inside the braces print(f"The result is {10+5}")Tecnologia
Agora que sabemos como criar f-strings, vamos ver como incorporar variáveis de forma eficaz. As f-strings permitem que você insira variáveis diretamente em suas strings de forma limpa e legível. Ao trabalhar com diferentes tipos de dados, as f-strings lidam com cada tipo de forma elegante.
Primeiro, vamos ver como as f-strings lidam com as variáveis básicas de string:
# Working with string variables
first_name ="John"
last_name ="Doe"print(f"Full name: {first_name}{last_name}")Tecnologia
Ao trabalhar com diferentes tipos de dados, as f-strings lidam com cada tipo de forma elegante. Vamos ver como as f-strings funcionam com vários tipos de dados do Python:
# Working with numeric types
integer_value =42
float_value =23.5print(f"Integer: {integer_value}")print(f"Float: {float_value}")Tecnologia
As cadeias de caracteres F funcionam perfeitamente com listas, permitindo que você acesse elementos individuais ou a lista inteira:
# Working with lists
fruits =["apple","banana","orange"]print(f"First fruit: {fruits[0]}")print(f"All fruits: {', '.join(fruits)}")Tecnologia
Saída
First fruit: apple
All fruits: apple, banana, orangeTecnologia
Ao trabalhar com dicionários, você pode acessar e formatar facilmente os valores do dicionário, conforme mostrado abaixo:
# Working with dictionaries
user_info ={"name":"Alice","age":28,"city":"New York"}print(f"User: {user_info['name']} from {user_info['city']}")Tecnologia
Os valores booleanos são fáceis de incorporar em f-strings, como mostrado abaixo:
# Working with boolean values
is_active =True
is_admin =Falseprint(f"Active status: {is_active}")print(f"Admin privileges: {is_admin}")Tecnologia
Saída
Active status:True
Admin privileges:FalseTecnologia
Podemos criar um código mais legível e de fácil manutenção se você entender como as f-strings funcionam com diferentes tipos de dados. Na próxima seção, veremos o uso mais avançado das f-strings.
Uso avançado de f-Strings
Avaliação de expressões
As f-strings funcionam bem quando você manipula expressões e cálculos diretamente nas strings. Em vez de calcular valores antecipadamente, você pode realizar operações diretamente dentro das chaves.
Primeiro, vamos ver como as f-strings lidam com operações aritméticas básicas. Observe como podemos realizar cálculos diretamente na formatação da cadeia de caracteres:
# Basic arithmetic operations
x =10
y =5print(f"Addition: {x + y}")print(f"Multiplication: {x * y}")print(f"Division with 2 decimal places: {x / y:.2f}")Tecnologia
Você também pode usar funções Python incorporadas em suas f-strings, o que as torna incrivelmente versáteis para a manipulação de dados. Veja como podemos aproveitar essas funções para manipular dados diretamente em nossas cadeias de caracteres.
numbers =[1,2,3,4,5]
text ="python"print(f"List length: {len(numbers)}")print(f"Maximum value: {max(numbers)}")print(f"Uppercase text: {text.upper()}")Tecnologia
Saída
List length:5
Maximum value:5
Uppercase text: PYTHONTecnologia
Expressões condicionais
Um dos recursos mais avançados das f-strings é a capacidade de incluir lógica condicional. Você pode usar o operador ternário para fazer com que a formatação da cadeia de caracteres responda às condições. Vamos começar com alguns exemplos simples usando o operador ternário:
# Simple conditional formatting
score =85print(f"Result: {'Pass'if score >=70else'Fail'}")# Multiple conditions in data analysis
value =42print(f"Status: {'High'if value >75else'Medium'if value >25else'Low'}")Tecnologia
A análise de dados do mundo real geralmente requer a combinação de condições com cálculos. Veja como podemos criar cenários de formatação mais sofisticados.
Stock Alert: Order more
Total Value: $749.85Tecnologia
Ao trabalhar com expressões mais longas, você pode melhorar a legibilidade dividindo-as em partes menores. Vamos ver como podemos dividir expressões mais longas para tornar nosso código mais fácil de manter:
# Complex expression broken down for clarity
value =75
threshold =50
multiplier =1.5
result = value > threshold
adjusted_value = value * multiplier if result else value
print(f"Adjusted Value: {adjusted_value}")print(f"Status: {'Exceeds threshold'if result else'Within limits'}")Tecnologia
As cadeias de caracteres F também podem ajudar na depuração usando o especificador '=' (introduzido no Python 3.8) para exibir os nomes das variáveis e seus valores, conforme mostrado abaixo:
# Debugging with f-strings
x =100
y =200print(f"{x=}, {y=}")print(f"{x + y=}")Tecnologia
As cadeias de caracteres F tornam as tarefas complexas de formatação de cadeias de caracteres mais intuitivas e legíveis. Na próxima seção, veremos como ajustar a aparência de nossas cadeias de caracteres formatadas com opções precisas de formatação de números e alinhamento de texto, habilidades essenciais para criar saídas de dados com aparência profissional.
Formatação com f-Strings
As f-strings oferecem recursos avançados para aprimorar a saída de dados, tornando-os mais legíveis e profissionais. Por meio de especificadores de formatação simples, podemos controlar tudo, desde as casas decimais até o alinhamento do texto, garantindo que nossos dados contem sua história de forma eficaz.
Vamos ver como podemos controlar diferentes aspectos da formatação usando f-strings.
Formatação de números
Ao trabalhar com dados numéricos, a formatação precisa pode tornar seus resultados mais profissionais e fáceis de ler.
Para formatar casas decimais, as cadeias de caracteres f usam dois pontos simples seguidos por um ponto e o número de casas decimais desejadas. casas decimais desejadas. Vamos ver isso com um exemplo:
# Controlling decimal places
pi =3.14159
price =19.99999
percentage =0.8525print(f"Pi to 2 decimal places: {pi:.2f}")print(f"Price rounded to 2 decimals: {price:.2f}")print(f"Percentage with 1 decimal: {percentage:.1%}")Tecnologia
Saída
Pi to 2 decimal places:3.14
Price rounded to 2 decimals:20.00
Percentage with1 decimal:85.2%Tecnologia
Quando lidamos com números grandes, geralmente queremos adicionar mil separadores para facilitar a leitura. Vamos ver como as f-strings podem nos ajudar a formatar esses números:
# Formatting large numbers
population =1234567
revenue =1234567.89# Using comma as thousand separatorprint(f"Population: {population:,}")print(f"Revenue: ${revenue:,.2f}")# Using underscore as thousand separatorprint(f"Population: {population:_}")print(f"Revenue: ${revenue:_.2f}")Tecnologia
A apresentação clara dos dados geralmente requer um texto alinhado corretamente. Vamos ver como as cordas f podem nos ajudar a obter um alinhamento perfeito em nossa saída.
Você pode alinhar o texto à esquerda, à direita ou ao centro usando os operadores '<', '>' e '^', respectivamente:
# Basic text alignment
name ="Python"
width =20print(f"Left aligned: |{name:<20}|")print(f"Right aligned: |{name:>20}|")print(f"Center aligned: |{name:^20}|")Tecnologia
Saída
Left aligned:|Python |
Right aligned:| Python|
Center aligned:| Python |Tecnologia
Para dados tabulares, a combinação do alinhamento com caracteres de preenchimento personalizado pode criar resultados com aparência profissional. Vamos ver como você pode criar tabelas bem formatadas:
# Creating a simple data table
languages =["Python","R","SQL"]
scores =[85,92,78]print("Programming Language Scores")print("-"*30)for lang, score inzip(languages, scores):print(f"{lang:<10} | {score:>5}")Tecnologia
Saída
Programming Language Scores
------------------------------
Python |85
R |92
SQL |78Tecnologia
Às vezes, você precisa preencher os números com zeros, especialmente ao trabalhar com códigos ou IDs. Vamos ver algumas técnicas de preenchimento de números:
A compreensão dessas técnicas de formatação é importante para os profissionais de dados que precisam apresentar os resultados de suas análises de forma profissional. Na próxima seção, veremos as f-strings de várias linhas, que se tornam particularmente úteis quando você precisa formatar blocos maiores de texto ou criar modelos de relatório mais complexos.
F-Strings de várias linhas
Ao trabalhar com blocos de texto maiores ou com formatação complexa de strings, as strings f de linha única podem se tornar pesadas e difíceis de ler. As f-strings de várias linhas do Python resolvem esse problema com elegância, permitindo que você crie um texto bem estruturado e legível em várias linhas. Vamos ver como você pode usar esse poderoso recurso de forma eficaz.
Criação de strings de várias linhas
As f-strings de várias linhas usam aspas triplas (""" ou ''') para abranger várias linhas e, ao mesmo tempo, manter o código limpo e legível. Pense neles como uma tela onde você pode pintar seu texto exatamente como deseja que ele apareça. Vamos ver como isso funciona:
# Basic multiline f-string
name ="Alice"
role ="Data Scientist"
experience =5
profile =f"""
Team Member Profile:
------------------
Name: {name}
Role: {role}
Experience: {experience} years
"""print(profile)Tecnologia
Saída
Team Member Profile:------------------
Name: Alice
Role: Data Scientist
Experience:5 yearsTecnologia
Entender a indentação em strings f de várias linhas é importante para uma formatação limpa. O recuo dentro das aspas triplas torna-se parte da própria cadeia de caracteres, conforme mostrado abaixo:
# Working with indentation
data ={'title':'Monthly Report','month':'October','value':1234.56}
report =f"""
{data['title']}
Month: {data['month']}
Value: ${data['value']:,.2f}
- Generated automatically
- All values in USD
"""print(report)Tecnologia
Saída
Monthly Report
Month: October
Value: $1,234.56- Generated automatically
- All values in USDTecnologia
Combinação de várias f-Strings
Às vezes, precisamos construir cordas complexas, peça por peça. O Python nos permite combinar várias f-strings de diferentes maneiras para obter a formatação exata de que precisamos, conforme mostrado abaixo:
# Building a report with multiple f-strings
title ="Sales Analysis"
period ="Q3 2024"
sales =150000
growth =27.5
header =f"""
{title}{'='*len(title)}
Period: {period}
"""
metrics =f"""
Performance Metrics:
- Total Sales: ${sales:,}
- Growth Rate: {growth}%
"""
notes =f"""
Additional Notes:
- All figures are preliminary
- Data updated as of {period}
"""# Combining all sections
full_report =f"{header}\n{metrics}\n{notes}"print(full_report)Tecnologia
Saída
Sales Analysis
=============
Period: Q3 2024
Performance Metrics:- Total Sales: $150,000- Growth Rate:27.5%
Additional Notes:- All figures are preliminary
- Data updated as of Q3 2024Tecnologia
Ao trabalhar com relatórios de análise de dados, talvez você precise formatar vários pontos de dados de forma estruturada. As cadeias de caracteres f de várias linhas são muito boas para criar uma saída clara e organizada, como mostrado abaixo:
# Creating a data analysis summary
metrics ={'mean':75.32,'median':72.50,'std_dev':12.45,'sample_size':1000}
summary =f"""
Statistical Summary
------------------
Sample Size: {metrics['sample_size']:,}
Central Tendency:
Mean: {metrics['mean']:.2f}
Median: {metrics['median']:.2f}
Variation:
Std Dev: {metrics['std_dev']:.2f}
"""print(summary)Tecnologia
As f-strings de várias linhas facilitam a criação de uma saída de texto legível e bem formatada para seu trabalho de análise de dados. Na próxima seção, veremos algumas armadilhas comuns a serem evitadas e as práticas recomendadas a serem seguidas ao trabalhar com f-strings, garantindo que a formatação das strings seja eficiente e de fácil manutenção.
Armadilhas comuns e práticas recomendadas
Ao trabalhar com f-strings, até mesmo desenvolvedores experientes em Python podem se deparar com desafios inesperados. Compreender essas armadilhas comuns e aprender as práticas recomendadas nos ajudará a escrever um código mais confiável e de fácil manutenção. Vamos dar uma olhada em algumas áreas importantes em que uma atenção cuidadosa pode fazer uma diferença significativa.
Fugindo do aparelho ortodôntico
Um dos desafios mais comuns ao trabalhar com f-strings é lidar com chaves literais no texto. Como as f-strings usam chaves para expressões, precisamos de um tratamento especial quando quisermos exibir chaves reais.
Primeiro, vamos ver o que acontece quando tentamos usar as chaves de forma incorreta:
# Incorrect way - will raise an errortry:print(f"This {variable} is inside {braces}")except NameError:print("The above code would raise an error")Tecnologia
Para exibir corretamente as chaves literais, precisamos duplicá-las. Aqui está a maneira correta:
# Correct way - doubling the bracesprint(f"This {{variable}} is inside {{braces}}")# Mixing literal and expression braces
name ="Python"print(f"{{Here's a name in braces: {name}}}")Tecnologia
Saída
This {variable}is inside {braces}{Here's a name in braces: Python}Tecnologia
Ao trabalhar com estruturas aninhadas, o escape adequado de chaves se torna ainda mais importante:
# Working with nested dictionary
data ={"name":"Alice","score":95}# Demonstrating nested dictionary formattingprint(f"Data: {{key: {data['name']}, value: {data['score']}}}")Tecnologia
As cordas em Fá não são apenas uma questão de conveniência, mas também de desempenho. Primeiro, vamos examinar uma concatenação simples de strings:
# Basic string formatting comparisonimport timeit
name ="Python"
version =3.9# Using + operator (slowest for multiple items)defconcat_plus():return"Running "+ name +" version "+str(version)# Using % formatting (old style)defformat_percent():return"Running %s version %s"%(name, version)# Using str.format()defformat_method():return"Running {} version {}".format(name, version)# Using f-stringdefformat_fstring():returnf"Running {name} version {version}"# Let's time each methodprint("Time taken (microseconds):")print(f"+ operator: {timeit.timeit(concat_plus, number=100000):.2f}")print(f"% operator: {timeit.timeit(format_percent, number=100000):.2f}")print(f"str.format: {timeit.timeit(format_method, number=100000):.2f}")print(f"f-string: {timeit.timeit(format_fstring, number=100000):.2f}")Tecnologia
Saída
Time taken (microseconds):+ operator:0.14% operator:0.15str.format:0.14
f-string:0.13Tecnologia
Ao lidar com loops, o uso adequado da string f se torna particularmente importante. Aqui está uma comparação de diferentes abordagens:
# Loop performance comparison
data =[("Alice",95),("Bob",87),("Charlie",92)]# Less efficient approach - creating new format string each timedefformat_inefficient():
result =[]for name, score in data:
result.append("Name: {} | Score: {}".format(name, score))return"\n".join(result)# More efficient approach - create template oncedefformat_efficient():
template ="Name: {} | Score: {}"
result =[]for name, score in data:
result.append(template.format(name, score))return"\n".join(result)# F-string approachdefformat_fstring():
result =[]for name, score in data:
result.append(f"Name: {name} | Score: {score}")return"\n".join(result)# Time comparisonprint("Time taken (microseconds):")print(f"Inefficient: {timeit.timeit(format_inefficient, number=10000):.2f}")print(f"Efficient: {timeit.timeit(format_efficient, number=10000):.2f}")print(f"F-string: {timeit.timeit(format_fstring, number=10000):.2f}")Tecnologia
Saída
Time taken (microseconds):
Inefficient:0.02
Efficient:0.02
F-string:0.01Tecnologia
Para cálculos complexos, é melhor executá-los fora da cadeia de caracteres f:
import math
radius =5# Bad practice - complex expression inside f-stringprint(f"Circle area: {math.pi * radius **2:.2f}")# Better practice - calculate complex expressions separately
area = math.pi * radius **2print(f"Circle area: {area:.2f}")Tecnologia
Lembre-se destas práticas recomendadas fundamentais ao trabalhar com cordas f:
Não use cordas f quando você não precisar delas. Para cadeias de caracteres estáticas, os literais de cadeias de caracteres regulares são mais eficientes.
Quando você precisar usar a mesma cadeia de caracteres várias vezes com valores diferentes, considere criar um modelo usando a formatação de cadeia de caracteres padrão.
Tenha cuidado com a complexidade da expressão dentro das f-strings - cálculos complexos geralmente são mais bem executados fora da f-string.
Exemplos práticos e casos de uso
f-strings tornam-se ferramentas valiosas para a criação de resultados claros e legíveis. Vamos ver alguns cenários práticos em que as f-strings tornam seu código mais elegante e seus resultados mais profissionais, concentrando-se especialmente em cenários de formatação de dados e depuração.
Formatação de dados
Ao trabalhar com análise de dados f-strings são boas na transformação de dados brutos em resultados bem formatados e fáceis de entender. Vamos ver alguns cenários comuns de formatação de dados que você encontrará em seu trabalho.
A formatação de dados financeiros exige o manuseio preciso de decimais e a notação adequada de moedas. Considere este exemplo em que estamos analisando dados de vendas:
Monthly Sales Report
-------------------
Total Sales: $123,456.79
Profit 18.6%
Units Sold:1,234
Profit: $22,912.94Tecnologia
Ao trabalhar com dados estatísticos, o alinhamento e a formatação adequados ajudam a tornar os resultados de sua análise mais legíveis. Vamos ver como as f-strings podem ajudar a formatar resumos estatísticos:
Durante o desenvolvimento e a análise de dadosDurante o desenvolvimento e a análise de dados, o registro e a depuração adequados são essenciais. As f-strings podem tornar essas tarefas mais simples e informativas. Vamos dar uma olhada em alguns cenários práticos de depuração:
# Enhanced debugging with f-stringsdefanalyze_data(data_list, threshold):# Debug information about input parametersprint(f"[DEBUG] Processing {len(data_list)} items with threshold {threshold}")
filtered_data =[x for x in data_list if x > threshold]# Debug information about processing resultsprint(f"[DEBUG] Found {len(filtered_data)} items above threshold")print(f"[DEBUG] Filtered ratio: {len(filtered_data)/len(data_list):.1%}")return filtered_data
# Example usage
data =[1,5,3,7,2,9,4,6]
result = analyze_data(data,5)Tecnologia
Saída
[DEBUG] Processing 8 items with threshold 5[DEBUG] Found 3 items above threshold
[DEBUG] Filtered ratio:37.5%Tecnologia
Ao depurar estruturas de dados complexas, as f-strings nos ajudam a criar resultados claros e informativos. Veja como podemos depurar um pipeline de processamento de dados:
# Debugging data transformationsdefprocess_user_data(user_info):print(f"""
[DEBUG] Processing user data:
Input type: {type(user_info)}
Fields present: {', '.join(user_info.keys())}
Data sample: {{k: user_info[k]for k inlist(user_info.keys())[:3]}}
""")# Example processing
user_data ={'name': user_info['name'].upper(),'age': user_info['age']+1# Simulated transformation}print(f"[DEBUG] Transformation complete: {user_data}")return user_data
# Example usage
sample_data ={'name':'alice','age':30,'city':'New York','occupation':'Data Scientist'}
processed = process_user_data(sample_data)Tecnologia
Saída
[DEBUG] Processing user data:
Input type:<class'dict'>
Fields present: name, age, city, occupation
Data sample:{'name':'alice','age':30,'city':'New York'}[DEBUG] Transformation complete:{'name':'ALICE','age':31}Tecnologia
Esses exemplos práticos demonstram como as f-strings podem aprimorar seu trabalho diário como profissional de dados. Se você estiver formatando resultados de análises, depurando transformações de dados complexas ou criando mensagens de log informativas, então as f-strings oferecem uma maneira limpa e eficiente de lidar com tarefas de formatação de strings.
Conclusão
As f-strings transformaram a maneira como os desenvolvedores Python lidam com a formatação de strings, oferecendo uma combinação perfeita de legibilidade, desempenho e flexibilidade. Conforme exploramos ao longo deste guia, eles oferecem uma maneira intuitiva de incorporar expressões e formatar dados diretamente em cadeias de caracteres, tornando nosso código mais limpo e de melhor manutenção.
Os benefícios do uso de f-strings vão além da sintaxe. Eles oferecem:
Maior facilidade de leitura: As variáveis e expressões são colocadas diretamente onde aparecerão na saída.
Desempenho aprimorado: As cadeias de caracteres F são mais rápidas do que os métodos tradicionais de formatação de cadeias de caracteres.
Maior flexibilidade: Desde a simples inserção de variáveis até expressões complexas, as f-strings lidam com tudo isso.
Recursos de depuração: O especificador '=' torna a introspecção e a depuração mais simples.
Perguntas frequentes sobre a cadeia de caracteres f do Python
Qual é a principal vantagem de usar f-strings em relação a outros métodos de formatação de strings?⌄
As cadeias de caracteres F oferecem um código mais legível e de fácil manutenção, permitindo a incorporação direta de expressões em cadeias de caracteres, além de oferecer melhor desempenho em comparação com métodos de formatação mais antigos.
Posso usar qualquer expressão Python dentro de f-strings?⌄
Você pode usar a maioria das expressões Python dentro de f-strings, incluindo variáveis, chamadas de função e cálculos, mas não pode usar instruções como atribuições ou expressões de várias linhas.
Como faço para controlar as casas decimais ao formatar números em f-strings?⌄
Você pode controlar as casas decimais usando especificadores de formato após dois pontos, como {number:.2f} para exibir um número com exatamente duas casas decimais.
As f-strings funcionam em todas as versões do Python? ⌄
As cadeias de caracteres F foram introduzidas no Python 3.6 e estão disponíveis em todas as versões mais recentes, mas não funcionam no Python 3.5 ou em versões anteriores.
Como faço para exibir chaves literalmente em uma string f? ⌄
Para exibir chaves literais em uma string f, você precisa duplicá-las, como usar {{ para exibir um único caractere {.
Sou redator de conteúdo de ciência de dados. Adoro criar conteúdo sobre tópicos de IA/ML/DS. Também exploro novas ferramentas de IA e escrevo sobre elas.
Saiba mais sobre a técnica de formatação f-string no Python 3.6. Neste tutorial, você verá as vantagens que ele oferece e verá alguns exemplos de casos de uso.
Neste tutorial, você aprenderá tudo sobre as cadeias de caracteres do Python: fatiamento e encadeamento, manipulação e formatação com a classe Formatter, cadeias de caracteres f, modelos e muito mais!
Este guia completo ensina os fundamentos do desenvolvimento backend com Python. Aprenda conceitos básicos, frameworks e boas práticas para começar a criar aplicações web.
Aumente o nível de suas habilidades de programação. Você aprenderá a otimizar o código, escrever funções e testes e usar as melhores práticas de engenharia de software.
As f-strings do Python representam uma maneira eficiente e intuitiva de formatar strings. As f-strings mudaram a forma como os desenvolvedores lidam com a formatação de strings no Python, tornando o código mais legível e de fácil manutenção do que nunca.
Imagem do autor
F-strings são literais de string prefixados com 'f' ou 'F' que contêm expressões dentro de chaves {}. Essas expressões são avaliadas em tempo de execução e, em seguida, formatadas usando o protocolo __format__. Diferentemente dos métodos tradicionais de formatação de strings, as f-strings oferecem uma maneira mais direta e legível de incorporar expressões Python diretamente em literais de strings.
Considere este cenário comum em que você precisa formatar uma simples saudação:
Você percebeu como as f-strings eliminam a sobrecarga cognitiva de combinar variáveis com espaços reservados? Essa clareza se torna ainda mais valiosa quando você lida com a formatação de dados complexos em aplicativos do mundo real, conforme mostrado abaixo:
Além da legibilidade, as f-strings se destacam pelo desempenho. Elas são mais rápidas do que %-formatting e str.format() porque são avaliadas em tempo de execução em vez de exigir várias operações com strings. O Python otimiza a avaliação de strings f, tornando-as uma opção eficiente para a formatação de strings.
Desde o Python 3.8, as f-strings se tornaram ainda mais úteis para depuração com a adição do especificador '='. Esse recurso prático exibe os nomes das variáveis e seus valores em uma única linha:
Neste artigo, daremos uma olhada nas f-strings, abordando tudo, desde a sintaxe básica até as técnicas avançadas de formatação. Você verá como avaliar expressões, formatar números e datas, lidar com cadeias de caracteres de várias linhas e aplicar práticas recomendadas em seu código.
Sintaxe básica das f-Strings do Python
As strings F oferecem uma maneira moderna e intuitiva de formatar strings em Python usando um prefixo simples e uma sintaxe de expressão. Vamos começar com os fundamentos da criação de cordas f.
Criando uma f-String
Para criar uma string f, basta adicionar a letra "f" ou "F" antes do literal da string. Os prefixos em letras minúsculas e maiúsculas funcionam de forma idêntica. É puramente uma questão de preferência de estilo de codificação. Veja como podemos criar cordas f básicas:
O verdadeiro poder das f-strings vem de sua capacidade de incorporar expressões dentro de chaves {}. Essas expressões são avaliadas em tempo de execução e seus valores são inseridos na string. Vamos ver isso em ação, conforme mostrado abaixo:
Saída
Incorporação de variáveis
Agora que sabemos como criar f-strings, vamos ver como incorporar variáveis de forma eficaz. As f-strings permitem que você insira variáveis diretamente em suas strings de forma limpa e legível. Ao trabalhar com diferentes tipos de dados, as f-strings lidam com cada tipo de forma elegante.
Primeiro, vamos ver como as f-strings lidam com as variáveis básicas de string:
Saída
Ao trabalhar com diferentes tipos de dados, as f-strings lidam com cada tipo de forma elegante. Vamos ver como as f-strings funcionam com vários tipos de dados do Python:
Saída
As cadeias de caracteres F funcionam perfeitamente com listas, permitindo que você acesse elementos individuais ou a lista inteira:
Saída
Ao trabalhar com dicionários, você pode acessar e formatar facilmente os valores do dicionário, conforme mostrado abaixo:
Saída
Os valores booleanos são fáceis de incorporar em f-strings, como mostrado abaixo:
Saída
Podemos criar um código mais legível e de fácil manutenção se você entender como as f-strings funcionam com diferentes tipos de dados. Na próxima seção, veremos o uso mais avançado das f-strings.
Uso avançado de f-Strings
Avaliação de expressões
As f-strings funcionam bem quando você manipula expressões e cálculos diretamente nas strings. Em vez de calcular valores antecipadamente, você pode realizar operações diretamente dentro das chaves.
Primeiro, vamos ver como as f-strings lidam com operações aritméticas básicas. Observe como podemos realizar cálculos diretamente na formatação da cadeia de caracteres:
Saída
Você também pode usar funções Python incorporadas em suas f-strings, o que as torna incrivelmente versáteis para a manipulação de dados. Veja como podemos aproveitar essas funções para manipular dados diretamente em nossas cadeias de caracteres.
Saída
Expressões condicionais
Um dos recursos mais avançados das f-strings é a capacidade de incluir lógica condicional. Você pode usar o operador ternário para fazer com que a formatação da cadeia de caracteres responda às condições. Vamos começar com alguns exemplos simples usando o operador ternário:
Saída
A análise de dados do mundo real geralmente requer a combinação de condições com cálculos. Veja como podemos criar cenários de formatação mais sofisticados.
Saída
Ao trabalhar com expressões mais longas, você pode melhorar a legibilidade dividindo-as em partes menores. Vamos ver como podemos dividir expressões mais longas para tornar nosso código mais fácil de manter:
Saída
As cadeias de caracteres F também podem ajudar na depuração usando o especificador '=' (introduzido no Python 3.8) para exibir os nomes das variáveis e seus valores, conforme mostrado abaixo:
Saída
As cadeias de caracteres F tornam as tarefas complexas de formatação de cadeias de caracteres mais intuitivas e legíveis. Na próxima seção, veremos como ajustar a aparência de nossas cadeias de caracteres formatadas com opções precisas de formatação de números e alinhamento de texto, habilidades essenciais para criar saídas de dados com aparência profissional.
Formatação com f-Strings
As f-strings oferecem recursos avançados para aprimorar a saída de dados, tornando-os mais legíveis e profissionais. Por meio de especificadores de formatação simples, podemos controlar tudo, desde as casas decimais até o alinhamento do texto, garantindo que nossos dados contem sua história de forma eficaz.
Vamos ver como podemos controlar diferentes aspectos da formatação usando f-strings.
Formatação de números
Ao trabalhar com dados numéricos, a formatação precisa pode tornar seus resultados mais profissionais e fáceis de ler.
Para formatar casas decimais, as cadeias de caracteres f usam dois pontos simples seguidos por um ponto e o número de casas decimais desejadas. casas decimais desejadas. Vamos ver isso com um exemplo:
Saída
Quando lidamos com números grandes, geralmente queremos adicionar mil separadores para facilitar a leitura. Vamos ver como as f-strings podem nos ajudar a formatar esses números:
Saída
Alinhamento e preenchimento de strings
A apresentação clara dos dados geralmente requer um texto alinhado corretamente. Vamos ver como as cordas f podem nos ajudar a obter um alinhamento perfeito em nossa saída.
Você pode alinhar o texto à esquerda, à direita ou ao centro usando os operadores '<', '>' e '^', respectivamente:
Saída
Para dados tabulares, a combinação do alinhamento com caracteres de preenchimento personalizado pode criar resultados com aparência profissional. Vamos ver como você pode criar tabelas bem formatadas:
Saída
Às vezes, você precisa preencher os números com zeros, especialmente ao trabalhar com códigos ou IDs. Vamos ver algumas técnicas de preenchimento de números:
Saída
A compreensão dessas técnicas de formatação é importante para os profissionais de dados que precisam apresentar os resultados de suas análises de forma profissional. Na próxima seção, veremos as f-strings de várias linhas, que se tornam particularmente úteis quando você precisa formatar blocos maiores de texto ou criar modelos de relatório mais complexos.
F-Strings de várias linhas
Ao trabalhar com blocos de texto maiores ou com formatação complexa de strings, as strings f de linha única podem se tornar pesadas e difíceis de ler. As f-strings de várias linhas do Python resolvem esse problema com elegância, permitindo que você crie um texto bem estruturado e legível em várias linhas. Vamos ver como você pode usar esse poderoso recurso de forma eficaz.
Criação de strings de várias linhas
As f-strings de várias linhas usam aspas triplas (""" ou ''') para abranger várias linhas e, ao mesmo tempo, manter o código limpo e legível. Pense neles como uma tela onde você pode pintar seu texto exatamente como deseja que ele apareça. Vamos ver como isso funciona:
Saída
Entender a indentação em strings f de várias linhas é importante para uma formatação limpa. O recuo dentro das aspas triplas torna-se parte da própria cadeia de caracteres, conforme mostrado abaixo:
Saída
Combinação de várias f-Strings
Às vezes, precisamos construir cordas complexas, peça por peça. O Python nos permite combinar várias f-strings de diferentes maneiras para obter a formatação exata de que precisamos, conforme mostrado abaixo:
Saída
Ao trabalhar com relatórios de análise de dados, talvez você precise formatar vários pontos de dados de forma estruturada. As cadeias de caracteres f de várias linhas são muito boas para criar uma saída clara e organizada, como mostrado abaixo:
Saída
As f-strings de várias linhas facilitam a criação de uma saída de texto legível e bem formatada para seu trabalho de análise de dados. Na próxima seção, veremos algumas armadilhas comuns a serem evitadas e as práticas recomendadas a serem seguidas ao trabalhar com f-strings, garantindo que a formatação das strings seja eficiente e de fácil manutenção.
Armadilhas comuns e práticas recomendadas
Ao trabalhar com f-strings, até mesmo desenvolvedores experientes em Python podem se deparar com desafios inesperados. Compreender essas armadilhas comuns e aprender as práticas recomendadas nos ajudará a escrever um código mais confiável e de fácil manutenção. Vamos dar uma olhada em algumas áreas importantes em que uma atenção cuidadosa pode fazer uma diferença significativa.
Fugindo do aparelho ortodôntico
Um dos desafios mais comuns ao trabalhar com f-strings é lidar com chaves literais no texto. Como as f-strings usam chaves para expressões, precisamos de um tratamento especial quando quisermos exibir chaves reais.
Primeiro, vamos ver o que acontece quando tentamos usar as chaves de forma incorreta:
Saída
Para exibir corretamente as chaves literais, precisamos duplicá-las. Aqui está a maneira correta:
Saída
Ao trabalhar com estruturas aninhadas, o escape adequado de chaves se torna ainda mais importante:
Saída
Para estruturas aninhadas mais complexas, o uso de aspas triplas pode melhorar a legibilidade, conforme mostrado abaixo:
Saída
Considerações sobre o desempenho
As cordas em Fá não são apenas uma questão de conveniência, mas também de desempenho. Primeiro, vamos examinar uma concatenação simples de strings:
Saída
Ao lidar com loops, o uso adequado da string f se torna particularmente importante. Aqui está uma comparação de diferentes abordagens:
Saída
Para cálculos complexos, é melhor executá-los fora da cadeia de caracteres f:
Lembre-se destas práticas recomendadas fundamentais ao trabalhar com cordas f:
Exemplos práticos e casos de uso
f-strings tornam-se ferramentas valiosas para a criação de resultados claros e legíveis. Vamos ver alguns cenários práticos em que as f-strings tornam seu código mais elegante e seus resultados mais profissionais, concentrando-se especialmente em cenários de formatação de dados e depuração.
Formatação de dados
Ao trabalhar com análise de dados f-strings são boas na transformação de dados brutos em resultados bem formatados e fáceis de entender. Vamos ver alguns cenários comuns de formatação de dados que você encontrará em seu trabalho.
A formatação de dados financeiros exige o manuseio preciso de decimais e a notação adequada de moedas. Considere este exemplo em que estamos analisando dados de vendas:
Saída
Ao trabalhar com dados estatísticos, o alinhamento e a formatação adequados ajudam a tornar os resultados de sua análise mais legíveis. Vamos ver como as f-strings podem ajudar a formatar resumos estatísticos:
Saída
Registro e depuração
Durante o desenvolvimento e a análise de dadosDurante o desenvolvimento e a análise de dados, o registro e a depuração adequados são essenciais. As f-strings podem tornar essas tarefas mais simples e informativas. Vamos dar uma olhada em alguns cenários práticos de depuração:
Saída
Ao depurar estruturas de dados complexas, as f-strings nos ajudam a criar resultados claros e informativos. Veja como podemos depurar um pipeline de processamento de dados:
Saída
Esses exemplos práticos demonstram como as f-strings podem aprimorar seu trabalho diário como profissional de dados. Se você estiver formatando resultados de análises, depurando transformações de dados complexas ou criando mensagens de log informativas, então as f-strings oferecem uma maneira limpa e eficiente de lidar com tarefas de formatação de strings.
Conclusão
As f-strings transformaram a maneira como os desenvolvedores Python lidam com a formatação de strings, oferecendo uma combinação perfeita de legibilidade, desempenho e flexibilidade. Conforme exploramos ao longo deste guia, eles oferecem uma maneira intuitiva de incorporar expressões e formatar dados diretamente em cadeias de caracteres, tornando nosso código mais limpo e de melhor manutenção.
Os benefícios do uso de f-strings vão além da sintaxe. Eles oferecem:
Se você quiser saber mais sobre como obter o máximo do Python, confira nosso trilha de habilidades de programação em Python.