As t-strings no Python são um novo recurso do Python 3.14 para criar templates que preservam, separadamente, o texto fixo e os valores interpolados. Elas lembram as f-strings na sintaxe, mas têm uma finalidade diferente: em vez de produzir imediatamente uma string pronta, retornam um objeto estruturado que pode ser validado, transformado, escapado ou renderizado por outra função.
Esse detalhe torna as t-strings especialmente úteis em situações nas quais concatenar texto e dados diretamente pode ser limitado ou inseguro. Geradores de HTML, consultas, logs estruturados, mensagens traduzidas, comandos e sistemas de templates podem inspecionar cada interpolação antes de decidir como tratá-la.
O que é uma t-string?
Uma t-string usa o prefixo t no lugar do prefixo f. Veja um exemplo simples:
produto = "Curso de Python"
preco = 99.90
template = t"Produto: {produto} — R$ {preco:.2f}"
print(type(template))
O resultado não é um objeto str. É uma instância de string.templatelib.Template. Ela contém uma sequência de trechos literais e objetos de interpolação. Isso permite que o código que recebe o template saiba quais partes foram digitadas pelo desenvolvedor e quais vieram de valores dinâmicos.
Essa separação é a principal diferença em relação às f-strings. Uma f-string avalia tudo e devolve uma string final. Uma t-string avalia as expressões, mas mantém sua estrutura para processamento posterior.
Como inspecionar strings e valores
O objeto Template oferece os atributos strings, interpolations e values. O primeiro contém os trechos fixos. O segundo contém objetos com informações completas sobre cada expressão. O terceiro é uma forma rápida de obter apenas os valores avaliados.
nome = "Ana"
pontos = 1250
template = t"Usuária {nome} possui {pontos} pontos"
print(template.strings)
print(template.values)
print(template.interpolations)
Nesse caso, strings terá três posições: o texto antes do nome, o texto entre o nome e os pontos e o texto final. Já values terá dois elementos. Por definição, a tupla de textos possui sempre um item a mais que a tupla de interpolações.
Para compreender melhor expressões e tipos no Python, vale revisar a introdução a Type Hints e o artigo sobre manipulação de strings em Python.
O objeto Interpolation
Cada item de template.interpolations é uma instância de Interpolation. Ela armazena quatro informações importantes: o valor calculado, o texto da expressão, a conversão solicitada e a especificação de formato.
total = 123.456
i = t"Total: {total!r:.2f}".interpolations[0]
print(i.value)
print(i.expression)
print(i.conversion)
print(i.format_spec)
Ao contrário das f-strings, conversões e formatos não precisam ser aplicados automaticamente. O processador do template decide o que fazer. Isso é poderoso porque permite criar regras próprias. Um renderizador HTML pode escapar valores; um gerador de logs pode guardar números como números; um sistema de internacionalização pode aplicar formatação de acordo com o idioma.
Renderizando uma t-string
Uma maneira didática de entender o recurso é criar uma função que percorre o template e transforma cada interpolação. O exemplo abaixo produz uma string final utilizando a função auxiliar convert e o protocolo format.
from string.templatelib import Interpolation, convert
def render(template):
partes = []
for item in template:
if isinstance(item, str):
partes.append(item)
continue
valor = convert(item.value, item.conversion)
if item.format_spec:
valor = format(valor, item.format_spec)
partes.append(str(valor))
return "".join(partes)
nome = "Carlos"
saldo = 1500.5
print(render(t"Cliente {nome}: R$ {saldo:.2f}"))
Essa implementação é propositalmente simples. Em um projeto real, você pode rejeitar tipos inesperados, escapar caracteres, registrar a expressão original e aplicar regras por campo. Para organizar esse tipo de código, veja também como criar módulos e pacotes e como documentar código com docstrings.
T-strings e segurança
T-strings não tornam automaticamente uma operação segura. Elas fornecem a estrutura necessária para que um processador aplique uma política segura. Isso significa que não basta receber um Template e concatenar tudo sem validação. O ganho aparece quando a função consumidora distingue conteúdo estático de conteúdo dinâmico.
Em HTML, por exemplo, valores interpolados podem ser escapados antes da renderização. Em consultas a banco de dados, o processador pode converter interpolações em parâmetros em vez de inserir valores diretamente na consulta. Em comandos de terminal, pode rejeitar argumentos perigosos ou chamar APIs que trabalham com listas de argumentos. A regra continua sendo: escolha uma API adequada ao contexto e não trate dados externos como código.
Concatenação de templates
Objetos Template podem ser concatenados com outros objetos Template. Contudo, não podem ser somados diretamente a uma string comum, pois isso seria ambíguo: a string deveria ser considerada texto fixo ou dado dinâmico?
saudacao = t"Olá, "
nome = "Beatriz"
mensagem = saudacao + t"{nome}!"
Para adicionar texto estático programaticamente, use Template("texto"). Para adicionar um valor dinâmico, crie uma Interpolation. Essa distinção explícita evita que um dado seja classificado incorretamente.
Pattern matching com interpolações
Os objetos Interpolation também funcionam com pattern matching. Assim, é possível decompor valor, expressão, conversão e formato usando match e case.
from string.templatelib import Interpolation
item = t"{42:.2f}".interpolations[0]
match item:
case Interpolation(valor, expressao, conversao, formato):
print(valor, expressao, conversao, formato)
Esse estilo é útil para construir processadores declarativos. Caso ainda não conheça a sintaxe, consulte o guia sobre match-case no Python.
Quando usar t-strings?
Use t-strings quando o código precisa receber um template estruturado e controlar a renderização. Bons exemplos incluem bibliotecas que geram HTML, sistemas de logging, ferramentas de internacionalização, validadores e APIs que precisam separar comandos de argumentos.
F-strings continuam sendo a opção mais simples quando você apenas precisa montar uma mensagem local e confiável. O objetivo das t-strings não é substituir todas as f-strings. Elas oferecem um protocolo para bibliotecas que precisam entender como a mensagem foi construída.
Compatibilidade e requisitos
O recurso foi adicionado no Python 3.14. Em versões anteriores, o prefixo t não está disponível. Confirme sua versão com python --version e mantenha os requisitos do projeto explícitos no pyproject.toml. Para trabalhar com configurações modernas, veja o guia sobre tomllib no Python.
A documentação oficial de string.templatelib detalha as classes e funções disponíveis. A proposta e as decisões de design estão registradas na PEP 750.
Conclusão
As t-strings introduzem uma forma estruturada de representar templates em Python. Elas mantêm texto fixo, valores, expressões, conversões e formatos acessíveis antes da renderização final. Isso facilita a criação de bibliotecas mais seguras, extensíveis e conscientes do contexto.
Comece com um processador pequeno, valide tipos e trate cada destino de maneira específica. HTML, SQL, terminal e logs têm regras diferentes. Quando essa separação é respeitada, as t-strings se tornam uma base elegante para sistemas de templates modernos.
