O Python sempre resolveu interpolação de strings gerando, no final das contas, uma str pronta — é o que fazem o %, o .format() e as f-strings. O Python 3.14 introduz um caminho diferente: as t-strings (template strings), definidas na PEP 750. Em vez de produzir uma string já montada, uma t-string produz um objeto Template, do novo módulo string.templatelib, que mantém separados os trechos literais e os valores interpolados — permitindo que o código que recebe o template decida como (e se) deve escapar, validar ou transformar cada parte antes de juntar tudo.
A sintaxe: t"..." em vez de f"..."
A sintaxe é idêntica à de uma f-string, só troca o prefixo f por t. A diferença aparece no tipo do resultado:
nome = "Ana"
f_string = f"Ola, {nome}!"
t_string = t"Ola, {nome}!"
print(type(f_string)) # <class 'str'>
print(type(t_string)) # <class 'string.templatelib.Template'>
print(f_string) # Ola, Ana!
print(t_string) # <string.templatelib.Template object at 0x...>
Uma t-string não é uma string — é um objeto que descreve como a string seria montada. Para obter texto final, é preciso processar esse objeto explicitamente.
Strings e interpolações separadas
Todo Template expõe dois atributos principais: strings, com os trechos literais, e interpolations, com um objeto Interpolation para cada expressão entre chaves:
nome = "Ana"
idade = 32
t = t"Usuario {nome}, {idade} anos"
print(t.strings) # ('Usuario ', ', ', ' anos')
print(len(t.interpolations)) # 2
primeira = t.interpolations[0]
print(primeira.value) # 'Ana'
print(primeira.expression) # 'nome'
Cada Interpolation carrega o valor já avaliado (value), o texto original da expressão (expression), além de conversion e format_spec — os mesmos conceitos de conversão (!r, !s) e especificação de formato (:.2f) que já existem nas f-strings, só que acessíveis como dados em vez de já aplicados.
Iterando sobre o template
Na prática, quem consome um Template normalmente não acessa strings e interpolations separadamente — itera sobre o próprio objeto, que alterna entre trechos de texto (str) e objetos Interpolation na ordem em que aparecem:
from string.templatelib import Interpolation
def renderizar(template):
partes = []
for item in template:
if isinstance(item, Interpolation):
partes.append(str(item.value))
else:
partes.append(item)
return "".join(partes)
nome = "Ana"
t = t"Ola, {nome}!"
print(renderizar(t)) # Ola, Ana!
Essa função renderizar() reproduz o comportamento de uma f-string comum — mas o ponto das t-strings é justamente poder trocar essa lógica por outra antes de chegar no join() final.
Caso de uso: escapar HTML automaticamente
Um dos motivadores da PEP 750 é evitar injeção ao montar HTML, SQL ou comandos de shell a partir de entrada do usuário. Com uma t-string, cada valor interpolado pode ser escapado antes de entrar no resultado final, sem que quem escreve o template precise lembrar disso:
from html import escape
from string.templatelib import Interpolation
def html_seguro(template):
partes = []
for item in template:
if isinstance(item, Interpolation):
partes.append(escape(str(item.value)))
else:
partes.append(item)
return "".join(partes)
comentario_usuario = "<script>alert('xss')</script>"
pagina = html_seguro(t"<p>Comentario: {comentario_usuario}</p>")
print(pagina)
# <p>Comentario: <script>alert('xss')</script></p>
Com uma f-string comum, esse escape precisaria ser feito manualmente em cada interpolação — e seria fácil esquecer em alguma delas. Com uma t-string, a função que processa o template garante o escape para toda interpolação, de forma consistente.
Caso de uso: montar consultas parametrizadas
O mesmo princípio se aplica a SQL: em vez de escapar texto, uma função que processa o template pode extrair os valores interpolados e devolver a query já com placeholders, junto da lista de parâmetros para o driver do banco:
from string.templatelib import Interpolation
def para_sql(template):
sql = []
parametros = []
for item in template:
if isinstance(item, Interpolation):
sql.append("%s")
parametros.append(item.value)
else:
sql.append(item)
return "".join(sql), parametros
usuario_id = 42
query, parametros = para_sql(t"SELECT * FROM usuarios WHERE id = {usuario_id}")
print(query) # SELECT * FROM usuarios WHERE id = %s
print(parametros) # [42]
# cursor.execute(query, parametros)
O valor de usuario_id nunca é concatenado diretamente na string SQL — ele chega separado, como os outros parâmetros que o driver já trata com segurança.
Quando usar
- Bibliotecas de templating HTML que precisam escapar toda interpolação por padrão, sem depender da disciplina de quem escreve o template.
- Construção seguro de queries SQL ou comandos de shell a partir de valores dinâmicos.
- Logging estruturado, onde os valores interpolados viram campos separados em vez de texto já concatenado.
- DSLs (linguagens de domínio específico) que reaproveitam a sintaxe familiar de interpolação do Python para gerar algo diferente de uma string.
Cuidados
Uma t-string sozinha não produz uma str — passar um Template direto para algo que espera texto (como escrever em um arquivo ou imprimir formatado) não funciona sem antes processá-lo. Isso também significa que trocar um f"..." por t"..." em código existente quebra tudo que esperava uma string pronta; a migração é intencional, não automática. Por fim, t-strings dependem do Python 3.14 — não há como usá-las em versões anteriores, nem via __future__.
Compatibilidade
T-strings e o módulo string.templatelib foram introduzidos no Python 3.14, lançado em outubro de 2025, como parte da PEP 750. Não dependem de nenhuma biblioteca externa, apenas da versão do interpretador.
Conclusão
As t-strings não substituem as f-strings — elas resolvem um problema diferente. Onde a f-string já entrega uma string pronta, a t-string entrega os ingredientes separados, deixando para o código que a recebe a decisão de como montar o resultado final. É um recurso voltado principalmente para quem escreve bibliotecas (templating, SQL, logging), mas vale conhecer mesmo fora desse contexto: entender a diferença entre f"..." e t"..." explica por que, de repente, código Python pode interpolar sem produzir uma string.
0 Comentário
Deixe seu Comentário!
Dúvida, sugestão ou só um "valeu!" — tudo é bem-vindo por aqui.