Las t-strings en Python son una función incorporada en Python 3.14 para crear plantillas que conservan por separado el texto estático y los valores interpolados. Su sintaxis se parece a la de las f-strings, pero el resultado es diferente. Una t-string no genera inmediatamente una cadena terminada: devuelve un objeto estructurado que otra función puede inspeccionar, validar, escapar, transformar o renderizar.
Esta separación resulta útil cuando combinar texto y datos directamente es demasiado limitado. Generadores de HTML, sistemas de logging estructurado, herramientas de traducción, constructores de consultas, envoltorios de comandos y motores de plantillas pueden analizar cada interpolación antes de decidir cómo procesarla.
¿Qué es una t-string?
Una t-string utiliza el prefijo t en lugar de f:
producto = "Curso de Python"
precio = 99.90
plantilla = t"Producto: {producto} — $ {precio:.2f}"
print(type(plantilla))
El resultado no es un objeto str. Es una instancia de string.templatelib.Template. Este objeto almacena fragmentos literales y objetos de interpolación. Así, el código que recibe la plantilla puede distinguir lo escrito por el desarrollador de los valores dinámicos.
Esa es la diferencia principal frente a una f-string. La f-string evalúa las expresiones y devuelve texto final. La t-string evalúa los valores, pero conserva la estructura para un procesamiento posterior.
Cómo inspeccionar textos y valores
Un objeto Template ofrece los atributos strings, interpolations y values. El primero contiene los fragmentos estáticos. El segundo contiene objetos completos de interpolación. El tercero permite obtener rápidamente los valores evaluados.
nombre = "Ana"
puntos = 1250
plantilla = t"La usuaria {nombre} tiene {puntos} puntos"
print(plantilla.strings)
print(plantilla.values)
print(plantilla.interpolations)
La tupla de textos tendrá tres elementos: el contenido anterior al nombre, el contenido intermedio y el texto final. La tupla de valores tendrá dos elementos. Por definición, siempre existe un fragmento de texto más que interpolaciones.
Para repasar conceptos relacionados, consulta la introducción a Type Hints y la guía sobre manejo de strings en Python.
El objeto Interpolation
Cada elemento de plantilla.interpolations es una instancia de Interpolation. Almacena cuatro datos importantes: el valor evaluado, el texto de la expresión, la conversión solicitada y la especificación 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)
A diferencia de las f-strings, la conversión y el formato no tienen que aplicarse automáticamente. El procesador decide cómo interpretar cada campo. Un renderizador HTML puede escapar valores, un sistema de logs puede conservar los números como números y una herramienta de internacionalización puede aplicar reglas según el idioma.
Renderizar una t-string
Un renderizador pequeño permite comprender el flujo. La siguiente función recorre la plantilla, aplica la conversión opcional, utiliza la especificación de formato y une el resultado.
from string.templatelib import Interpolation, convert
def renderizar(plantilla):
partes = []
for elemento in plantilla:
if isinstance(elemento, str):
partes.append(elemento)
continue
valor = convert(elemento.value, elemento.conversion)
if elemento.format_spec:
valor = format(valor, elemento.format_spec)
partes.append(str(valor))
return "".join(partes)
cliente = "Carlos"
saldo = 1500.5
print(renderizar(t"Cliente {cliente}: $ {saldo:.2f}"))
Esta implementación es intencionalmente sencilla. En producción, el código puede rechazar tipos no permitidos, escapar caracteres peligrosos, registrar la expresión original y aplicar políticas distintas por campo. Para organizar este código, revisa cómo crear módulos y paquetes y cómo documentar Python con docstrings.
T-strings y seguridad
Las t-strings no vuelven segura una operación de forma automática. Proporcionan la estructura necesaria para que un procesador implemente una política segura. El beneficio desaparece si una función concatena todos los componentes sin validación.
En HTML, los valores interpolados pueden escaparse antes de renderizarse. En una operación de base de datos, el procesador puede convertir las interpolaciones en parámetros en lugar de insertarlas directamente en SQL. En comandos del sistema, un envoltorio puede rechazar argumentos peligrosos o utilizar una API que reciba una lista de parámetros.
La regla general continúa siendo la misma: los datos externos no deben tratarse como código. La plantilla estructurada ayuda a establecer una frontera clara entre fragmentos estáticos y datos dinámicos.
Concatenar plantillas
Un objeto Template puede concatenarse con otro Template. Sin embargo, no puede sumarse directamente a una string normal. La restricción evita una ambigüedad importante: ¿la string normal debe considerarse texto estático confiable o valor dinámico?
saludo = t"Hola, "
nombre = "Beatriz"
mensaje = saludo + t"{nombre}!"
Para añadir texto estático de manera programática, utiliza Template("texto"). Para añadir un valor dinámico, crea una Interpolation. La clasificación explícita facilita que el procesador aplique la política correcta.
Pattern matching con interpolaciones
Los objetos Interpolation admiten pattern matching estructural. Puedes descomponer valor, expresión, conversión y formato con match y case.
from string.templatelib import Interpolation
elemento = t"{42:.2f}".interpolations[0]
match elemento:
case Interpolation(valor, expresion, conversion, formato):
print(valor, expresion, conversion, formato)
Este enfoque es práctico para procesadores declarativos. Si todavía no dominas esta sintaxis, consulta la guía de match-case en Python.
Ideas de uso práctico
Un procesador HTML puede aceptar strings, números y objetos de marcado seguro, escapando cualquier otro valor. Un procesador de logs puede utilizar el texto de la expresión como nombre del campo y conservar el valor original para búsquedas y métricas.
Un sistema de traducción puede tratar el texto estático como una clave de mensaje y aplicar formato local a fechas, monedas y cantidades. Un constructor de consultas puede guardar cada valor dinámico en una lista separada de parámetros. Aun así, debe validar cuidadosamente la estructura permitida; una t-string mejora la visibilidad, pero no reemplaza el diseño seguro de la API.
¿Cuándo conviene usar t-strings?
Utiliza t-strings cuando una biblioteca o aplicación necesita recibir una plantilla estructurada y controlar el renderizado final. Son adecuadas para HTML, logs estructurados, internacionalización, validadores y APIs específicas de un dominio que deban separar instrucciones y datos.
Las f-strings siguen siendo más simples cuando solo necesitas construir un mensaje local a partir de valores confiables. Las t-strings no buscan reemplazar todas las f-strings. Su objetivo es ofrecer un protocolo para herramientas que necesitan entender cómo se compuso el mensaje.
Compatibilidad y requisitos
Las t-strings se incorporaron en Python 3.14. Los intérpretes anteriores no reconocen el prefijo. Comprueba la versión con python --version y declara la versión mínima en pyproject.toml. La guía sobre tomllib en Python puede ayudarte con configuraciones modernas.
La documentación oficial de string.templatelib describe la API completa. La motivación y las decisiones de diseño están registradas en la PEP 750.
Conclusión
Las t-strings ofrecen una representación estructurada de plantillas en Python. Mantienen disponibles el texto estático, los valores, las expresiones, las conversiones y los formatos hasta que un procesador genera el resultado final.
Empieza con un renderizador pequeño, valida los tipos aceptados y define reglas específicas para cada destino. HTML, SQL, comandos, traducciones y logs requieren políticas diferentes. Con esas fronteras bien definidas, las t-strings se convierten en una base elegante y extensible para procesar plantillas modernas en Python.
