Las t-strings son una función de Python 3.14 diseñada para representar texto interpolado como datos estructurados. Su sintaxis se parece a la de las f-strings, pero no produce inmediatamente una cadena final. En su lugar, devuelve un objeto de plantilla que mantiene separados el texto literal, los valores interpolados, las conversiones y las especificaciones de formato. Esta diferencia permite validar, escapar, transformar o auditar cada valor antes de generar la salida.
La funcionalidad está disponible mediante string.templatelib. Resulta útil cuando construir una cadena directamente haría perder información necesaria para una biblioteca. Algunos casos frecuentes son la generación segura de HTML, los logs estructurados, la internacionalización, los constructores de consultas y los lenguajes específicos de dominio.
Diferencias entre t-strings y f-strings
Una f-string evalúa sus expresiones y devuelve un str. Esto es práctico para mensajes sencillos, pero la estructura original desaparece. Después de ensamblar la cadena, ya no es posible distinguir de forma fiable qué parte era literal y qué parte procedía de una variable. Una t-string conserva esos límites.
nombre = "Ana"
edad = 28
plantilla = t"Usuario: {nombre}, edad: {edad}"
print(type(plantilla))
print(plantilla.strings)
print(plantilla.interpolations)El atributo strings contiene los segmentos literales. El atributo interpolations reúne los valores insertados y sus metadatos. Un renderizador puede procesar cada componente según sus propias reglas.
Objetos Template e Interpolation
El módulo expone principalmente Template e Interpolation. Un Template representa la secuencia completa. Cada Interpolation almacena el valor evaluado, el texto de la expresión, una conversión opcional y la especificación de formato.
Por ejemplo, una interpolación como {precio:.2f} conserva tanto el valor como .2f. El renderizador puede respetar esa especificación, rechazarla o sustituirla por una política propia. Lo mismo ocurre con conversiones como !r.
Cómo recorrer una plantilla
Una plantilla puede recorrerse en el orden original. Durante la iteración aparecen cadenas literales y objetos de interpolación, lo que facilita crear renderizadores explícitos.
from string.templatelib import Interpolation
def renderizar(plantilla):
partes = []
for elemento in plantilla:
if isinstance(elemento, Interpolation):
partes.append(str(elemento.value))
else:
partes.append(elemento)
return "".join(partes)
usuario = "Carlos"
print(renderizar(t"Hola, {usuario}!"))Este ejemplo es deliberadamente simple. Un renderizador real podría escapar HTML, ocultar secretos, conservar tipos para telemetría o devolver una estructura distinta de una cadena.
HTML más seguro
Uno de los usos más interesantes es el escape dependiente del contexto. Insertar datos externos directamente en HTML puede crear vulnerabilidades. Con una t-string, el renderizador puede escapar solo los valores interpolados y conservar el marcado literal escrito por el desarrollador.
from html import escape
from string.templatelib import Interpolation
def html_seguro(plantilla):
salida = []
for elemento in plantilla:
if isinstance(elemento, Interpolation):
salida.append(escape(str(elemento.value)))
else:
salida.append(elemento)
return "".join(salida)
comentario = "<script>alert('x')</script>"
pagina = html_seguro(t"<p>{comentario}</p>")Las t-strings no vuelven segura una salida de manera automática. Proporcionan la estructura necesaria para implementar una política de seguridad. El renderizador sigue siendo responsable de aplicar el tratamiento correcto.
Logs estructurados
Un sistema de logging puede guardar por separado los nombres de las expresiones y sus valores, en lugar de convertir todo en texto. Esto mejora los filtros, las métricas, las alertas y las búsquedas.
def registrar(plantilla):
campos = {}
for interp in plantilla.interpolations:
campos[interp.expression] = interp.value
print({"mensaje": plantilla.strings, "campos": campos})
pedido_id = 845
estado = "pagado"
registrar(t"Pedido {pedido_id} quedó {estado}")Los valores mantienen sus tipos. Una plataforma de observabilidad puede tratar un entero como entero sin extraerlo de una frase. También puede ocultar campos sensibles según el nombre de la expresión o el tipo del valor.
Consultas y comandos
Las t-strings pueden utilizarse como entrada para bibliotecas que construyen consultas o comandos. Un procesador puede convertir los valores interpolados en placeholders, mantener los parámetros separados, aceptar solo tipos permitidos y rechazar expresiones inseguras.
Sin embargo, una t-string por sí sola no evita SQL injection ni command injection. La biblioteca consumidora debe implementar parametrización real y validación específica para el contexto. La ventaja es que el texto literal y los valores están separados.
Conversiones y formato
Las t-strings conservan conversion y format_spec, pero el renderizador decide si debe aplicarlos. La función convert() puede procesar conversiones compatibles y format() puede aplicar la especificación de formato.
from string.templatelib import Interpolation, convert
def renderizar_formato(plantilla):
resultado = []
for elemento in plantilla:
if not isinstance(elemento, Interpolation):
resultado.append(elemento)
continue
valor = convert(elemento.value, elemento.conversion)
resultado.append(format(valor, elemento.format_spec))
return "".join(resultado)Un renderizador robusto debe tratar especificaciones vacías, conversiones ausentes, formatos inválidos y objetos personalizados con cuidado.
Internacionalización
Conservar los límites de interpolación puede ayudar a sistemas de traducción. En vez de traducir una frase ya ensamblada, una herramienta puede mantener placeholders estables y aplicar después reglas locales para números, fechas y monedas.
Esto no reemplaza un sistema completo de internacionalización. Las reglas de plural, género gramatical, selección regional y catálogos de mensajes siguen necesitando herramientas específicas. Las t-strings ofrecen una entrada estructurada útil para esos sistemas.
Cuándo conviene usarlas
Usa t-strings cuando la estructura de la interpolación siga siendo importante después de evaluar la expresión. Son adecuadas para motores de plantillas, logging estructurado, generación segura de marcado, DSL, localización y bibliotecas que inspeccionan o validan valores. Para un mensaje sencillo mostrado en consola, una f-string sigue siendo más clara.
También debes considerar la compatibilidad. Las t-strings requieren Python 3.14 o posterior. Una biblioteca compatible con versiones anteriores deberá ofrecer una alternativa. Puedes ampliar el tema con la guía de Type Hints en Python, el artículo sobre introspección con inspect, el contenido de f-strings para depuración y la categoría de Python Avanzado.
Diseñar un buen renderizador
Mantén cada renderizador pequeño y específico. HTML, SQL, comandos de shell, URLs y logs requieren reglas distintas. Valida los tipos permitidos, define cómo manejar formatos inválidos y evita ejecutar código adicional durante el renderizado. Prueba valores vacíos, Unicode, caracteres especiales, objetos personalizados y datos sensibles.
No supongas que toda expresión debe convertirse en texto. Un logger estructurado puede conservar el objeto original. Un adaptador de base de datos puede convertirlo en parámetro enlazado. Un renderizador HTML puede aceptar marcado confiable solo mediante un tipo contenedor explícito.
Rendimiento
Las t-strings añaden procesamiento estructurado, por lo que no son automáticamente más rápidas que las f-strings. Su ventaja es el control. Evita inspeccionar repetidamente la misma plantilla cuando puedas reutilizar una representación procesada. Mide el rendimiento en la aplicación real.
Para consultar los detalles oficiales, revisa la documentación de string.templatelib y la PEP 750, que explica la motivación y el diseño de las template strings.
Conclusión
Las t-strings no sustituyen a las f-strings en todos los casos. Resuelven un problema diferente: conservar una expresión interpolada como datos estructurados para que otro componente tome decisiones informadas. Al separar literales, valores, conversiones y formatos, string.templatelib permite renderizadores más seguros, logs más ricos y herramientas especializadas. Usa f-strings cuando solo necesites texto y t-strings cuando necesites controlar cómo se produce.
