Skip to content

Python F-Strings: O Guia Completo para Formatação de Strings

Soren Atelier
Name
Soren Atelier

Updated on

A formatação de strings é uma das operações mais comuns em Python, mas tem sido uma fonte de frustração por anos. O operador % usa códigos de formato crípticos herdados do C. O método .format() espalha valores longe de onde aparecem no template. A concatenação de strings com + força você a converter tipos manualmente e produz código confuso e difícil de ler. Cada abordagem parece adicionar fricção a uma tarefa que deveria ser simples: colocar um valor dentro de uma string.

O problema piora em projetos reais. Você precisa formatar moeda com duas casas decimais, alinhar colunas em um relatório, preencher números com zeros à esquerda, exibir porcentagens e formatar timestamps — tudo enquanto mantém o código legível. Com métodos antigos de formatação, você acaba mantendo duas estruturas paralelas: a string template e a lista de argumentos. Um único erro de reordenação quebra tudo silenciosamente, produzindo saída errada em vez de um erro.

O Python 3.6 introduziu as f-strings (formatted string literals), e elas mudaram a formatação de strings permanentemente. Ao prefixar uma string com f e incorporar expressões diretamente dentro de {chaves}, as f-strings mantêm os valores próximos de onde aparecem. Elas são mais rápidas que todos os outros métodos de formatação. Suportam a gama completa de especificações de formato. E no Python 3.8, ganharam um recurso integrado de depuração com o especificador =. Este guia cobre todas as capacidades das f-strings com exemplos práticos e executáveis.

📚

    O que são F-Strings?

    F-strings, formalmente chamadas de "formatted string literals", foram introduzidas na PEP 498 (opens in a new tab) e lançadas com o Python 3.6. O conceito é simples: prefixe qualquer string com f (ou F), e o Python avalia qualquer expressão dentro de chaves {} em tempo de execução, convertendo o resultado para string e inserindo-o na saída.

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

    O prefixo f funciona com aspas simples, aspas duplas e aspas triplas:

    single = f'Hello, {name}'
double = f"Hello, {name}"
triple_double = f"""Hello, {name}"""
triple_single = f'''Hello, {name}'''

    Por baixo dos panos, o Python compila f-strings em uma série de concatenações de strings e operações format() em tempo de análise. É por isso que as f-strings são mais rápidas que chamar .format() você mesmo — o interpretador otimiza a operação diretamente.

    Sintaxe Básica de F-Strings

    A sintaxe principal é simples: escreva f"texto {expressão} mais texto". O Python avalia a expressão, chama str() no resultado e insere na string.

    # Variables
city = "Tokyo"
population = 13960000
 
print(f"{city} has a population of {population}.")
# Output: Tokyo has a population of 13960000.
 
# You can use either f or F
print(F"Welcome to {city}!")
# Output: Welcome to Tokyo!

    Você pode colocar qualquer número de expressões dentro de uma única f-string:

    first = "Grace"
last = "Hopper"
title = "Rear Admiral"
year = 1906
 
bio = f"{title} {first} {last}, born {year}, lived to {1992 - year} years."
print(bio)
# Output: Rear Admiral Grace Hopper, born 1906, lived to 86 years.

    Expressões Dentro de F-Strings

    F-strings não apenas inserem variáveis. Elas avaliam qualquer expressão Python válida entre as chaves. Isso inclui aritmética, chamadas de método, chamadas de função, expressões ternárias, indexação de listas, acesso a dicionários e mais.

    Aritmética e Matemática

    x = 15
y = 4
 
print(f"{x} + {y} = {x + y}")
print(f"{x} / {y} = {x / y:.2f}")
print(f"{x} ** {y} = {x ** y}")
print(f"{x} % {y} = {x % y}")
# Output:
# 15 + 4 = 19
# 15 / 4 = 3.75
# 15 ** 4 = 50625
# 15 % 4 = 3

    Chamadas de Método

    text = "  hello, python world  "
 
print(f"Stripped: '{text.strip()}'")
print(f"Title case: '{text.strip().title()}'")
print(f"Upper: '{text.strip().upper()}'")
print(f"Replace: '{text.strip().replace('python', 'f-string')}'")
# Output:
# Stripped: 'hello, python world'
# Title case: 'Hello, Python World'
# Upper: 'HELLO, PYTHON WORLD'
# Replace: 'hello, f-string world'

    Chamadas de Função

    def calculate_bmi(weight_kg, height_m):
    return weight_kg / (height_m ** 2)
 
weight = 70
height = 1.75
 
print(f"BMI: {calculate_bmi(weight, height):.1f}")
# Output: BMI: 22.9
 
# Built-in functions
items = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Items: {items}")
print(f"Count: {len(items)}, Sum: {sum(items)}, Min: {min(items)}, Max: {max(items)}")
# Output:
# Items: [3, 1, 4, 1, 5, 9, 2, 6]
# Count: 8, Sum: 31, Min: 1, Max: 9

    Expressões Ternárias (Condicionais)

    score = 85
status = f"Result: {'PASS' if score >= 60 else 'FAIL'}"
print(status)
# Output: Result: PASS
 
temperature = -5
print(f"Water is {'frozen' if temperature <= 0 else 'liquid' if temperature < 100 else 'steam'}.")
# Output: Water is frozen.

    Acesso a Dicionários e Listas

    user = {"name": "Bob", "role": "engineer", "level": 3}
scores = [88, 92, 76, 95, 81]
 
print(f"{user['name']} is a level {user['level']} {user['role']}.")
# Output: Bob is a level 3 engineer.
 
print(f"First score: {scores[0]}, Last score: {scores[-1]}")
# Output: First score: 88, Last score: 81

    Especificações de Formato: Números, Alinhamento e Preenchimento

    O verdadeiro poder das f-strings aparece nas especificações de formato. Após a expressão, adicione dois pontos : seguido de uma especificação de formato. A sintaxe geral é:

    {expression:[[fill]align][sign][#][0][width][grouping_option][.precision][type]}

    Isso parece denso, mas cada parte é opcional. Vamos analisar com exemplos.

    Casas Decimais e Precisão de Ponto Flutuante

    O especificador .Nf controla quantas casas decimais um float exibe:

    pi = 3.141592653589793
 
print(f"Default:    {pi}")
print(f"2 decimals: {pi:.2f}")
print(f"4 decimals: {pi:.4f}")
print(f"0 decimals: {pi:.0f}")
print(f"8 decimals: {pi:.8f}")
# Output:
# Default:    3.141592653589793
# 2 decimals: 3.14
# 4 decimals: 3.1416
# 0 decimals: 3
# 8 decimals: 3.14159265

    Separadores de Milhares

    Números grandes se tornam legíveis instantaneamente com agrupamento por vírgula ou sublinhado:

    revenue = 1234567890
small_amount = 1234.5
 
print(f"Revenue: {revenue:,}")
print(f"Revenue: {revenue:_}")
print(f"Amount: ${small_amount:,.2f}")
# Output:
# Revenue: 1,234,567,890
# Revenue: 1_234_567_890
# Amount: $1,234.50

    Formatação de Porcentagem

    O tipo % multiplica o valor por 100 e anexa um sinal de porcentagem:

    completion = 0.876
error_rate = 0.034
growth = 1.25
 
print(f"Completion: {completion:.1%}")
print(f"Error rate: {error_rate:.2%}")
print(f"Growth: {growth:.0%}")
# Output:
# Completion: 87.6%
# Error rate: 3.40%
# Growth: 125%

    Notação Científica

    avogadro = 6.022e23
planck = 6.626e-34
 
print(f"Avogadro: {avogadro:.3e}")
print(f"Planck: {planck:.4E}")
# Output:
# Avogadro: 6.022e+23
# Planck: 6.6260E-34

    Bases Inteiras: Binário, Octal, Hexadecimal

    value = 255
 
print(f"Decimal:     {value:d}")
print(f"Binary:      {value:b}")
print(f"Octal:       {value:o}")
print(f"Hex (lower): {value:x}")
print(f"Hex (upper): {value:X}")
print(f"With prefix: {value:#b}  {value:#o}  {value:#x}")
# Output:
# Decimal:     255
# Binary:      11111111
# Octal:       377
# Hex (lower): ff
# Hex (upper): FF
# With prefix: 0b11111111  0o377  0xff

    Alinhamento e Preenchimento

    Especificadores de alinhamento controlam como valores se posicionam dentro de uma largura dada. Use < para esquerda, > para direita e ^ para centro:

    label = "Python"
 
print(f"|{label:<20}|")   # Left-align in 20 chars
print(f"|{label:>20}|")   # Right-align
print(f"|{label:^20}|")   # Center
print(f"|{label:*^20}|")  # Center with * fill
print(f"|{label:->20}|")  # Right with - fill
# Output:
# |Python              |
# |              Python|
# |       Python       |
# |*******Python*******|
# |--------------Python|

    Preenchimento com zeros para números é comum em formatação de relatórios:

    for i in [1, 42, 100, 7, 999]:
    print(f"ID: {i:05d}")
# Output:
# ID: 00001
# ID: 00042
# ID: 00100
# ID: 00007
# ID: 00999

    Construindo Tabelas Alinhadas

    Combinando alinhamento com especificações de formato, produzimos tabelas limpas:

    products = [
    ("Laptop Pro", 1299.99, 45),
    ("Wireless Mouse", 29.50, 230),
    ("USB-C Hub", 54.95, 120),
    ("Monitor 27in", 449.00, 67),
]
 
print(f"{'Product':<18} {'Price':>10} {'Stock':>7}")
print("-" * 37)
for name, price, stock in products:
    print(f"{name:<18} ${price:>9.2f} {stock:>7,}")
print("-" * 37)
 
total_value = sum(p * s for _, p, s in products)
print(f"{'Total Value':<18} ${total_value:>9,.2f}")
 
# Output:
# Product               Price   Stock
# -------------------------------------
# Laptop Pro         $ 1,299.99      45
# Wireless Mouse     $    29.50     230
# USB-C Hub          $    54.95     120
# Monitor 27in       $   449.00      67
# -------------------------------------
# Total Value        $91,498.05

    Formatação de Data e Hora com F-Strings

    F-strings aceitam códigos de formato strftime diretamente, o que significa que você pode formatar objetos datetime sem chamar .strftime():

    from datetime import datetime, date, timedelta
 
now = datetime.now()
 
print(f"ISO format:  {now:%Y-%m-%d %H:%M:%S}")
print(f"US format:   {now:%m/%d/%Y}")
print(f"Long format: {now:%B %d, %Y at %I:%M %p}")
print(f"Day of week: {now:%A}")
print(f"Short month: {now:%b %d}")
# Output (varies by current time):
# ISO format:  2026-02-13 14:30:00
# US format:   02/13/2026
# Long format: February 13, 2026 at 02:30 PM
# Day of week: Friday
# Short month: Feb 13

    Isso funciona com objetos date também:

    from datetime import date
 
birthday = date(1995, 8, 15)
today = date.today()
age_days = (today - birthday).days
 
print(f"Birthday: {birthday:%B %d, %Y}")
print(f"Days alive: {age_days:,}")
print(f"Years (approx): {age_days / 365.25:.1f}")
# Output:
# Birthday: August 15, 1995
# Days alive: 11,139
# Years (approx): 30.5

    F-Strings Multilinha

    F-strings com aspas triplas permitem construir blocos de texto formatados. Cada linha em uma f-string com aspas triplas pode conter expressões {}:

    project = "Data Pipeline"
owner = "Engineering Team"
status = "In Progress"
completion = 0.73
budget = 250000
spent = 182500
 
report = f"""
========================================
  Project Status Report
========================================
  Project:    {project}
  Owner:      {owner}
  Status:     {status}
  Completion: {completion:.0%}
  Budget:     ${budget:>12,}
  Spent:      ${spent:>12,}
  Remaining:  ${budget - spent:>12,}
========================================
"""
 
print(report)

    Você também pode construir f-strings multilinha concatenando múltiplas f-strings com concatenação implícita de strings (colocando-as uma ao lado da outra sem operador):

    name = "Alice"
role = "Data Scientist"
years = 5
 
bio = (
    f"Name: {name}\n"
    f"Role: {role}\n"
    f"Experience: {years} years\n"
    f"Seniority: {'Senior' if years >= 5 else 'Mid-level'}"
)
 
print(bio)
# Output:
# Name: Alice
# Role: Data Scientist
# Experience: 5 years
# Seniority: Senior

    Esta segunda abordagem evita a nova linha inicial e problemas de indentação que às vezes vêm com strings de aspas triplas.

    O Especificador = para Depuração (Python 3.8+)

    O Python 3.8 adicionou o especificador = às f-strings, e é um dos recursos mais úteis de depuração da linguagem. Quando você escreve f"{expression=}", o Python imprime tanto o texto da expressão quanto seu valor.

    x = 42
y = 17
 
print(f"{x=}")
print(f"{y=}")
print(f"{x + y=}")
print(f"{x * y=}")
# Output:
# x=42
# y=17
# x + y=59
# x * y=714

    Você pode combinar = com especificadores de formato:

    price = 49.99
tax_rate = 0.0825
total = price * (1 + tax_rate)
 
print(f"{price=:.2f}")
print(f"{tax_rate=:.1%}")
print(f"{total=:.2f}")
# Output:
# price=49.99
# tax_rate=8.2%
# total=54.12

    O especificador = preserva espaços em branco ao seu redor. Adicionar espaços antes do = formata a saída:

    name = "Alice"
score = 95
 
print(f"{name = }")
print(f"{score = }")
# Output:
# name = 'Alice'
# score = 95

    Note que para strings, = usa repr() por padrão (mostrando as aspas). Para números, usa str().

    Depurando Expressões Complexas

    O especificador = funciona com qualquer expressão, tornando-se uma forma rápida de inspecionar valores intermediários:

    data = [23, 45, 12, 67, 34, 89, 56]
 
print(f"{len(data)=}")
print(f"{sum(data)=}")
print(f"{sum(data)/len(data)=:.2f}")
print(f"{sorted(data)=}")
print(f"{max(data) - min(data)=}")
# Output:
# len(data)=7
# sum(data)=326
# sum(data)/len(data)=46.57
# sorted(data)=[12, 23, 34, 45, 56, 67, 89]
# max(data) - min(data)=77

    Se você trabalha em notebooks Jupyter e se pega constantemente adicionando chamadas print(f"{variable=}") enquanto depura, considere o RunCell (opens in a new tab), um agente de IA que roda diretamente dentro do Jupyter. O RunCell entende as variáveis na memória do seu notebook e pode inspecionar, explicar e sugerir correções sem que você precise escrever instruções de debug manualmente. É especialmente útil ao percorrer transformações de dados onde você precisa verificar valores intermediários em múltiplas células.

    F-Strings Aninhadas

    Você pode aninhar f-strings dentro de f-strings. O caso de uso mais comum são especificações de formato dinâmicas, onde a largura ou precisão vem de uma variável:

    # Dynamic precision
value = 3.14159265
for precision in range(1, 6):
    print(f"  {precision} decimals: {value:.{precision}f}")
# Output:
#   1 decimals: 3.1
#   2 decimals: 3.14
#   3 decimals: 3.142
#   4 decimals: 3.1416
#   5 decimals: 3.14159
    # Dynamic width
header = "Report"
for width in [20, 30, 40]:
    print(f"|{header:^{width}}|")
# Output:
# |       Report       |
# |            Report            |
# |                 Report                 |
    # Nested f-string for formatting a list
values = [1.234, 56.789, 0.001, 999.999]
decimals = 2
formatted = f"Results: {', '.join(f'{v:.{decimals}f}' for v in values)}"
print(formatted)
# Output: Results: 1.23, 56.79, 0.00, 1000.00

    Use aninhamento com moderação. Se uma f-string requer mais de um nível de aninhamento, extraia a lógica interna para uma variável ou função para legibilidade.

    F-Strings vs Outros Métodos de Formatação de Strings

    Python tem quatro abordagens principais para formatação de strings. Aqui está uma comparação direta:

    Featuref-string f"...{x}...".format() "...{}...".format(x)% operator "...%s..." % xTemplate Template("...$x...")
    Python Version3.6+2.6+AllAll
    ReadabilityExcellent -- values inlineGood -- numbered/named placeholdersFair -- positional codesGood -- named placeholders
    PerformanceFastest~1.5-2x slower~1.3-1.8x slowerSlowest
    Arbitrary ExpressionsYesLimitedNoNo
    Debug Specifier (=)Yes (3.8+)NoNoNo
    Reusable TemplatesNoYesYesYes
    Safe for User InputNoNoNoYes (safe_substitute)
    Type FormattingFullFullPartialNone
    name = "Charlie"
balance = 1234.56
 
# f-string (recommended)
print(f"{name} has ${balance:,.2f}")
 
# .format()
print("{} has ${:,.2f}".format(name, balance))
 
# % formatting
print("%s has $%,.2f" % (name, balance))  # Note: %  does not support comma grouping
 
# Template (from string module)
from string import Template
t = Template("$name has $balance")
print(t.substitute(name=name, balance=f"${balance:,.2f}"))

    Quando usar cada um:

    • F-strings: Escolha padrão para código novo. Use sempre que estiver rodando Python 3.6+.
    • .format(): Use quando precisar de templates reutilizáveis armazenados em variáveis ou arquivos de configuração.
    • % formatting: Código legado apenas. Nenhuma razão para usar em novos projetos.
    • Template: Use quando a string de formato vem de entrada não confiável de usuário (não pode executar expressões arbitrárias).

    Comparação de Desempenho

    F-strings são mais rápidas porque o Python as compila em bytecode otimizado em tempo de análise, evitando a sobrecarga de chamadas de método e parsing de argumentos que .format() e % exigem.

    import timeit
 
name = "Alice"
age = 30
score = 95.5
 
# Benchmark each method with 1 million iterations
fstring_time = timeit.timeit(
    'f"{name} scored {score:.1f} at age {age}"',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
format_time = timeit.timeit(
    '"{} scored {:.1f} at age {}".format(name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
percent_time = timeit.timeit(
    '"%s scored %.1f at age %d" % (name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
concat_time = timeit.timeit(
    'name + " scored " + str(score) + " at age " + str(age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
print(f"f-string:      {fstring_time:.4f}s (baseline)")
print(f"str.format():  {format_time:.4f}s ({format_time/fstring_time:.2f}x slower)")
print(f"% formatting:  {percent_time:.4f}s ({percent_time/fstring_time:.2f}x slower)")
print(f"concatenation: {concat_time:.4f}s ({concat_time/fstring_time:.2f}x slower)")
 
# Typical results:
# f-string:      0.0850s (baseline)
# str.format():  0.1450s (1.71x slower)
# % formatting:  0.1100s (1.29x slower)
# concatenation: 0.1200s (1.41x slower)

    A diferença de desempenho aumenta à medida que as expressões se tornam mais complexas. Em loops apertados processando milhares de registros, as f-strings fazem uma diferença mensurável.

    Erros Comuns e Pegadinhas

    Escapando Chaves

    Para incluir um { ou } literal em uma f-string, duplique-os:

    value = 42
 
# Literal braces around a value
print(f"{{{value}}}")
# Output: {42}
 
# JSON-like output
key = "name"
val = "Alice"
print(f'{{"{key}": "{val}"}}')
# Output: {"name": "Alice"}
 
# Just literal braces, no interpolation
print(f"Use {{variable}} syntax in f-strings")
# Output: Use {variable} syntax in f-strings

    Barras Invertidas Dentro de Expressões

    Você não pode usar caracteres de barra invertida dentro da parte de expressão {} de uma f-string. Esta é uma escolha deliberada de design para legibilidade:

    items = ["apple", "banana", "cherry"]
 
# This causes a SyntaxError:
# print(f"{'\\n'.join(items)}")
 
# Solution 1: assign to a variable first
newline = "\n"
print(f"{newline.join(items)}")
 
# Solution 2: use a separate operation
joined = "\n".join(items)
print(f"Items:\n{joined}")
 
# Solution 3: use chr()
print(f"{chr(10).join(items)}")

    Conflitos de Aspas

    Quando sua f-string usa aspas duplas, expressões dentro devem usar aspas simples (ou vice-versa):

    data = {"name": "Alice", "age": 30}
 
# Use single quotes inside when f-string uses double quotes
print(f"Name: {data['name']}, Age: {data['age']}")
 
# Or use double quotes inside when f-string uses single quotes
print(f'Name: {data["name"]}, Age: {data["age"]}')
 
# With triple quotes, you have more flexibility
print(f"""Name: {data["name"]}, Age: {data["age"]}""")

    F-Strings Não São Constantes

    F-strings são avaliadas em tempo de execução, o que significa que você não pode usá-las como valores padrão de argumentos ou constantes de nível de módulo que dependem de estado de runtime:

    # This works but evaluates at call time, not definition time
def greet(name, template=None):
    if template is None:
        template = f"Hello, {name}!"  # Evaluated here
    return template
 
# For true templates, use str.format()
TEMPLATE = "Hello, {name}! You have {count} messages."
print(TEMPLATE.format(name="Alice", count=5))

    Cuidado com Expressões Grandes

    Só porque você pode colocar qualquer expressão em uma f-string não significa que deve. Mantenha expressões de f-string simples:

    # Hard to read -- too much logic inside the f-string
result = f"{'%.2f' % (sum(x**2 for x in range(100)) / 100)}"
 
# Much better -- compute first, then format
mean_square = sum(x**2 for x in range(100)) / 100
result = f"{mean_square:.2f}"

    F-Strings Brutas (Raw)

    Combinar os prefixos r (raw) e f cria uma f-string bruta onde barras invertidas são tratadas literalmente (sem sequências de escape) enquanto expressões ainda são avaliadas:

    user = "admin"
folder = "projects"
 
# Raw f-string for Windows paths
path = rf"C:\Users\{user}\{folder}\data.csv"
print(path)
# Output: C:\Users\admin\projects\data.csv
 
# Useful for regex patterns with dynamic parts
import re
prefix = "user"
pattern = rf"\b{prefix}_\d+\b"
text = "Found user_123 and user_456 in the log"
matches = re.findall(pattern, text)
print(f"Matches: {matches}")
# Output: Matches: ['user_123', 'user_456']

    Ambos rf"..." e fr"..." são válidos — a ordem dos prefixos não importa.

    F-Strings em Fluxos de Trabalho de Ciência de Dados

    F-strings são inestimáveis em ciência de dados para formatar saída, construir labels dinâmicos e criar resumos legíveis de resultados numéricos.

    Formatando Saída Numérica

    import statistics
 
data = [23.4, 45.1, 31.8, 52.3, 41.7, 38.9, 29.6, 47.2]
 
mean = statistics.mean(data)
median = statistics.median(data)
stdev = statistics.stdev(data)
cv = stdev / mean  # coefficient of variation
 
print(f"Sample size:    {len(data)}")
print(f"Mean:           {mean:.2f}")
print(f"Median:         {median:.2f}")
print(f"Std deviation:  {stdev:.2f}")
print(f"CV:             {cv:.1%}")
print(f"Range:          {min(data):.1f} - {max(data):.1f}")
# Output:
# Sample size:    8
# Mean:           38.75
# Median:         40.30
# Std deviation:  9.87
# CV:             25.5%
# Range:          23.4 - 52.3

    Trabalhando com DataFrames do Pandas

    import pandas as pd
 
df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C", "Widget D"],
    "revenue": [125000, 89000, 234000, 67000],
    "units": [1250, 2100, 980, 3400],
})
 
# Summary statistics with f-strings
total_rev = df["revenue"].sum()
avg_price = (df["revenue"] / df["units"]).mean()
 
print(f"Total Revenue:  ${total_rev:>12,}")
print(f"Avg Unit Price: ${avg_price:>12,.2f}")
print(f"Products:       {len(df):>12,}")
 
# Dynamic column formatting
for _, row in df.iterrows():
    unit_price = row["revenue"] / row["units"]
    print(f"  {row['product']:<12} | Revenue: ${row['revenue']:>9,} | Units: {row['units']:>5,} | $/unit: ${unit_price:.2f}")
 
# Output:
# Total Revenue:  $     515,000
# Avg Unit Price: $       56.00
# Products:              4
#   Widget A     | Revenue: $  125,000 | Units: 1,250 | $/unit: $100.00
#   Widget B     | Revenue: $   89,000 | Units: 2,100 | $/unit: $42.38
#   Widget C     | Revenue: $  234,000 | Units:   980 | $/unit: $238.78
#   Widget D     | Revenue: $   67,000 | Units: 3,400 | $/unit: $19.71

    Quando sua análise de dados vai além de resumos de texto e você precisa de exploração interativa, o PyGWalker (opens in a new tab) pode transformar qualquer DataFrame do pandas em uma visualização interativa tipo Tableau com uma única linha de código. Em vez de formatar números manualmente para relatórios estáticos, você pode arrastar e soltar colunas para construir gráficos, aplicar filtros e explorar padrões visualmente — tudo dentro do seu notebook Jupyter.

    import pandas as pd
import pygwalker as pyg
 
# After preparing your DataFrame with well-formatted columns
df = pd.DataFrame({
    "Month": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
    "Revenue": [125000, 134000, 158000, 142000, 167000, 189000],
    "Growth": [0.05, 0.072, 0.179, -0.101, 0.176, 0.132],
})
 
# Add formatted columns for display
df["Revenue_Display"] = df["Revenue"].apply(lambda x: f"${x:,.0f}")
df["Growth_Display"] = df["Growth"].apply(lambda x: f"{x:+.1%}")
 
# Launch interactive visualization
# pyg.walk(df)

    Formatando Resultados de Modelos

    # Formatting machine learning results
metrics = {
    "accuracy": 0.9234,
    "precision": 0.8891,
    "recall": 0.9456,
    "f1_score": 0.9164,
    "auc_roc": 0.9678,
}
 
print("Model Evaluation Results")
print("=" * 35)
for metric, value in metrics.items():
    bar_length = int(value * 20)
    bar = "#" * bar_length + "-" * (20 - bar_length)
    print(f"  {metric:<12} {value:.4f}  [{bar}]")
# Output:
# Model Evaluation Results
# ===================================
#   accuracy     0.9234  [##################--]
#   precision    0.8891  [#################---]
#   recall       0.9456  [##################--]
#   f1_score     0.9164  [##################--]
#   auc_roc      0.9678  [###################-]

    Flags de Conversão: !s, !r, e !a

    F-strings suportam três flags de conversão que controlam como o valor da expressão é convertido antes da formatação:

    • !s chama str() no valor (comportamento padrão)
    • !r chama repr() no valor
    • !a chama ascii() no valor
    text = "Hello\tWorld"
name = "Caf\u00e9"
 
print(f"str:   {text!s}")
print(f"repr:  {text!r}")
print(f"ascii: {name!a}")
# Output:
# str:   Hello	World
# repr:  'Hello\tWorld'
# ascii: 'Caf\xe9'

    A flag !r é particularmente útil para depuração, pois mostra a representação bruta incluindo aspas e caracteres de escape. Funciona bem junto com o especificador =.

    Perguntas Frequentes

    O que são f-strings do Python e quando foram introduzidas?

    F-strings (formatted string literals) são um mecanismo de formatação de strings introduzido no Python 3.6 através da PEP 498. Elas permitem incorporar expressões Python diretamente dentro de literais de string prefixando a string com f e colocando expressões dentro de chaves. F-strings são avaliadas em tempo de execução, oferecem a melhor legibilidade entre todas as opções de formatação de strings do Python, e são mais rápidas que str.format() e formatação % porque compilam em bytecode otimizado em tempo de análise.

    Como formatar números com vírgulas e casas decimais em f-strings?

    Use a especificação de formato após dois pontos dentro das chaves. Para vírgulas como separadores de milhares, use :, — por exemplo, f"{1234567:,}" produz "1,234,567". Para casas decimais, use :.Nf onde N é o número de dígitos — por exemplo, f"{3.14159:.2f}" dá "3.14". Combine ambos: f"{1234.5:,.2f}" resulta em "1,234.50". Para porcentagens, use :.N% que multiplica por 100 e anexa um sinal de porcentagem: f"{0.85:.1%}" produz "85.0%".

    O que é o especificador = de f-strings e como ele ajuda na depuração?

    O especificador = foi adicionado no Python 3.8 e imprime tanto o texto da expressão quanto seu valor. Escrever f"{variable=}" gera variable=value. Isso elimina a necessidade de digitar o nome da variável duas vezes ao depurar. Funciona com qualquer expressão: f"{len(data)=}" gera len(data)=42. Você pode combiná-lo com especs de formato: f"{price=:.2f}" gera price=49.99. É uma das formas mais rápidas de inspecionar valores intermediários durante o desenvolvimento.

    Posso usar f-strings com strings multilinha?

    Sim. Use aspas triplas (f"""...""" ou f'''...''') para f-strings multilinha. Cada linha pode conter placeholders {expression}. Alternativamente, você pode concatenar múltiplas f-strings usando concatenação implícita de strings colocando-as adjacentes uma à outra em parênteses: (f"linha 1: {x}\n" f"linha 2: {y}\n"). A abordagem de aspas triplas é melhor para templates e relatórios; a abordagem de concatenação evita problemas de nova linha inicial.

    As f-strings são mais rápidas que str.format() e % formatting?

    Sim. F-strings são consistentemente o método de formatação de strings mais rápido em Python. Elas tipicamente executam 1,5 a 2 vezes mais rápido que str.format() e 1,3 a 1,8 vezes mais rápido que % formatting. A vantagem de velocidade vem da otimização em tempo de compilação onde o Python converte f-strings diretamente em bytecode eficiente.

    Como incluo chaves literais em uma f-string?

    Duplique as chaves. Use {{ para uma { literal e }} para uma } literal. Por exemplo, f"{{value}}" gera {value} como texto simples. Para envolver um valor interpolado em chaves, use f"{{{variable}}}" — as chaves duplicadas externas produzem chaves literais, enquanto as chaves simples internas disparam a interpolação.

    Conclusão

    F-strings são o padrão para formatar strings em Python moderno. Elas combinam a melhor legibilidade de qualquer abordagem de formatação com o melhor desempenho, e suportam a gama completa de especificações de formato: precisão decimal, separadores de milhares, porcentagens, notação científica, alinhamento, preenchimento, formatação de datas e conversões de base.

    As coisas principais para lembrar:

    • Prefixe com f e coloque expressões dentro de {chaves}.
    • Use : seguido de uma especificação de formato para controle preciso da saída (:.2f, :,,, :.1%, :<20).
    • Use = após a expressão para depuração (f"{variable=}"). Requer Python 3.8+.
    • Escape chaves literais duplicando-as: {{ e }}.
    • Não coloque barras invertidas dentro da expressão {}. Atribua a uma variável primeiro.
    • Mantenha expressões simples. Se a lógica dentro de {} é difícil de ler, extraia-a.
    • Use .format() apenas quando precisar de templates reutilizáveis armazenados como variáveis.

    F-strings lidam com tudo, desde depuração rápida com print() até geração de relatórios de produção. Uma vez que você as adota, não há razão para voltar a métodos antigos de formatação. Seja construindo pipelines de dados, formatando saídas de modelos de ML ou gerando relatórios financeiros, as f-strings entregam código limpo, rápido e legível.

    📚