Se você já precisou escrever uma string multilinha dentro de uma função ou classe em Python, sabe que a situação fica estranha rápido.

A PEP 822 propõe as d-strings (de dedent) para o Python 3.15, uma nova sintaxe que remove indentação automaticamente de strings multilinhas. Simples assim.

O problema que elas resolvem

Imagine que você precisa montar um texto dentro de uma função:

1
2
3
4
5
6
7

def gerar_email(nome: str) -> str:
    return textwrap.dedent(f"""\
        Olá, {nome}!

        Seu cadastro foi confirmado.
        Obrigado por se inscrever.
    """)

As opções que temos hoje são ruins:

1. Sem indentação — o código fica visualmente quebrado
2. Concatenação de strings — verboso e fácil de errar
3. textwrap.dedent() — funciona, mas tem custo em runtime, não é compatível com t-strings e exige o """\ feio na abertura

As d-strings resolvem tudo isso com uma sintaxe nativa.

Como funciona

Basta adicionar o prefixo d antes das aspas triplas:

1
2
3
4
5
6
7

def gerar_email(nome: str) -> str:
    return df"""
        Olá, {nome}!

        Seu cadastro foi confirmado.
        Obrigado por se inscrever.
        """

O resultado é o mesmo texto sem a indentação extra, sem chamada de função em runtime.

Regras principais

• Só funciona com aspas triplas (""" ou ''')
• O conteúdo deve começar na linha seguinte à abertura
• A indentação das aspas de fechamento determina quanto é removido
• Pode ser combinado com outros prefixos: f, r, b, t (em qualquer ordem)

A indentação do fechamento importa

O quanto é removido depende de onde você coloca as aspas de fechamento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

s = d"""
    Olá
    Mundo
    """
# Resultado: 'Olá\nMundo\n'  (4 espaços removidos)

s = d"""
    Olá
    Mundo
  """
# Resultado: '  Olá\n  Mundo\n'  (apenas 2 espaços removidos)

Isso dá controle fino sobre o resultado final, sem precisar de nenhuma função auxiliar.

Combinando com outros prefixos

As d-strings funcionam com todos os outros prefixos que você já conhece:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# df-string: dedent + interpolação
mensagem = df"""
    Usuário: {usuario}
    Plano: {plano}
    """

# dr-string: dedent + raw (backslashes preservados)
regex_pattern = dr"""
    \d{3}
    \.\d{3}
    \.\d{3}-\d{2}
    """

# dt-string: dedent + template string (Python 3.14+)
template = dt"""
    Olá, {nome}!
    Bem-vindo ao {sistema}.
    """

Por que não usar textwrap.dedent() mesmo?

A função existe e funciona, mas tem limitações reais:

A maior vantagem prática é a compatibilidade com as t-strings (PEP 750, Python 3.14), que são avaliadas em tempo de compilação e não aceitam processamento posterior com dedent.

Status atual

A PEP 822 ainda é uma proposta em rascunho (Draft), direcionada ao Python 3.15. A implementação de referência já existe (methane/cpython#108), mas ainda precisa passar pelo processo de aprovação oficial.

Não é nada para usar em produção agora, mas é uma adição bastante pragmática ao que o Python já oferece. Sem mágica, sem overhead, só uma sintaxe mais limpa para um problema que todo programador Python já enfrentou.