Python 3.14 adds t"" template strings for structured interpolation, enabling safe rendering, inspection, and transformation before output.
Python 3.14 introduces a powerful new feature: template strings, formalized in PEP 750. While () offer convenient inline interpolation, they immediately evaluate to plain strings, making it impossible to extract metadata, control rendering behavior later, or inspect what expressions were interpolated.
f-stringsf""Template strings (t"") solve this by producing a structured object (Template) rather than a string. This gives developers programmatic access to:
{username})'abhimanyu'):.2f, !r, etc.)The result: a foundation for building safer, inspectable, and reusable string handling, especially useful for logging, templating systems, web output, and structured pipelines.
Many use cases (HTML, shell commands, logs) appear doable with f-strings. So why switch?
t-strings are:¶f-strings give you a result. t-strings give you control.
Before diving into real-world use cases, here’s how a basic t-string works:
Instead of evaluating directly to "Hello, abhimanyu", the template gives you structured access to:
"Hello, ")user)'abhimanyu')When dynamically creating shell commands (e.g., in automation scripts), inserting user input directly using f-strings can lead to shell injection or break quoting:
Use a t-string to delay rendering and sanitize input values before final construction:
Output:
With template strings, the values are still separate at the point of rendering, allowing for safe pre-processing.
Traditional log lines mix human-readable and machine-readable output, making it hard to extract fields for analysis:
Template strings let you access all interpolated values directly and use them to generate structured logs:
Output:
This makes log parsing, alerting, and dashboarding much simpler, no extra parsing or duplication required.
Displaying user input in HTML (e.g., admin dashboards, reports) risks breaking the layout or worse, injecting malicious content.
Process interpolated values before rendering:
Output:
You now have full control over how and when sanitization happens, without altering the input or changing its source.
f-strings hide formatting behavior internally. There’s no way to override how conversions like !r, !s, or :.2f behave.
Build a custom renderer using metadata from each Interpolation:
Output:
This lets you reimplement f-string behavior, or extend it, to suit your formatting logic or domain-specific rules.
You may want to build a full template by composing smaller pieces, especially in configuration generators, reusable UI components, or dynamic log builders.
With f-strings, this is impossible since they render immediately:
Template strings allow composition, Template + Template or Template + str returns a new Template object:
Output:
Just like f-strings, t-strings evaluate expressions at the moment the string is created, not when you render it:
Output:
This means:
t"" literalUse t-strings when you want to combine templates, inspect values, or transform output.
Don’t expect them to re-evaluate expressions at render time, they capture state once, not on demand.
Template strings in Python 3.14 are not a replacement for f-strings, they're an evolution for more advanced, controlled use cases.
Where f-strings prioritize simplicity and immediate output, t-strings prioritize structure, safety, and flexibility. They let you inspect expressions, modify rendering behavior, sanitize values on the fly, and reuse templates as objects rather than static text.
If you're working on:
then t-strings are the right tool.
Use f-strings when all you need is a string.
Use t-strings when you need control before the string is finalized.
Template strings (t"") return a structured Template object instead of a plain string. Unlike f-strings, which immediately produce a string, t-strings give access to interpolation metadata like variable names, evaluated values, and formatting instructions. This enables introspection, transformation, and safer rendering.
Use template strings when:
No. Like f-strings, template strings eagerly evaluate their expressions at the time the string is created. This means all referenced variables must already be defined, and changes to variables after t-string creation won’t affect the template’s stored values.
Yes. You can access individual interpolations (e.g., their values, conversion flags, and formatting specifiers) and build custom rendering logic. This is useful for replicating or extending f-string behavior, such as overriding how !r or :.2f is interpreted.
Get new posts, tools, and tips delivered straight to your inbox.
Follow along with walkthroughs and tutorials, especially on Rancher and DevOps topics.
A small act of support goes a long way. You're helping me stay consistent and keep the content flowing.
ls "/var/www"Action: deploy, Environment: staging, Version: v2.3.1 | {"action": "deploy", "env": "staging", "version": "v2.3.1"}<div><script>alert(1)</script></div>User: 'admin', Score: 97.4Stage: prodstagingfrom string.templatelib import Template
user = "abhimanyu"
template = t"Hello, {user}"
print(template.strings)
# Output: ('Hello, ', '')
print(template.interpolations[0].expression)
# Output: 'user'
print(template.interpolations[0].value)
# Output: 'abhimanyu'command = f'ls "{path}"' # f-string renders immediately—no way to validate `path` laterfrom string.templatelib import Template, Interpolation
def build_command(template: Template) -> str:
def sanitize(val):
return str(val).replace('"', '\\"') # naive quote escape
return "".join(
sanitize(item.value) if isinstance(item, Interpolation) else item
for item in template
)
command = "ls"
path = "/var/www"
print(build_command(t'{command} "{path}"'))# f-string: Cannot extract key-value fields cleanly
logline = f"User {user} did {action}"import json
from string.templatelib import Template, Interpolation
class DebugLog:
def __init__(self, template: Template):
self.template = template
def __str__(self):
message = "".join(
str(item.value) if isinstance(item, Interpolation) else item
for item in self.template
)
fields = {
item.expression: item.value
for item in self.template
if isinstance(item, Interpolation)
}
return f"{message} | {json.dumps(fields)}"
action = "deploy"
env = "staging"
version = "v2.3.1"
log = DebugLog(t"Action: {action}, Environment: {env}, Version: {version}")
print(log)# Dangerous if input is raw
f"<div>{user_input}</div>"def safe_html(template: Template) -> str:
def escape(val):
return str(val).replace("<", "<").replace(">", ">")
return "".join(
escape(item.value) if isinstance(item, Interpolation) else item
for item in template
)
user_input = "<script>alert(1)</script>"
print(safe_html(t"<div>{user_input}</div>"))from typing import Literal
from string.templatelib import Interpolation, Template
def convert(value, conversion: Literal["a", "r", "s"] | None) -> str:
return {
"a": ascii,
"r": repr,
"s": str,
None: lambda x: x
}[conversion](value)
def render(template: Template) -> str:
parts = []
for item in template:
if isinstance(item, str):
parts.append(item)
elif isinstance(item, Interpolation):
val = convert(item.value, item.conversion)
parts.append(format(val, item.format_spec))
return "".join(parts)
name = "admin"
score = 97.438
print(render(t"User: {name!r}, Score: {score:.1f}"))# f-string: this won't combine as reusable components
f"Stage: " + f"{env}"from string.templatelib import Interpolation
env = "prod" # Must be defined *before* the t-string
t1 = t"Stage: "
t2 = t"{env}"
combined = t1 + t2
# Render result
print("".join(str(item.value if isinstance(item, Interpolation) else item) for item in combined))env = "staging"
t = t"{env}"
env = "prod" # Changing later has no effect
print(t.interpolations[0].value)
CVE-2025-1767 exposes root-level access on nodes via a deprecated volume plugin; Kubernetes 1.33 will disable it by default
Enhance Kubernetes pod scheduling with dynamic affinity using matchLabelKeys and mismatchLabelKeys for safer rollouts and tenant isolation.
Pods can now exclude tainted nodes during topology spread calculations, improving placement predictability.
FeaturedGitHub cut hosted runner prices but planned fees for self-hosted Actions, triggering backlash. The change was paused. Here’s what happened and what to expect.
FeaturedKubernetes 1.34 brings GA features, scheduler speedups, kubelet and networking updates, plus security and performance boosts for production clusters.
FeaturedStep-by-step guide to RKE2 autoscaler setup with Rancher. Learn cluster autoscaler Helm deployment, scaling benefits, limits & troubleshooting.
Learn the key differences between `removesuffix()` and `rstrip()` in Python. Avoid common pitfalls and choose the right method for precise string manipulation.
Explore the top 10 Python trends in 2025, from faster runtimes and type safety to AI, web, data, DevOps, and quantum. Stay ahead in every domain with Python.
Python 3.14 simplifies exception handling with PEP 758, letting you drop parentheses when catching multiple exceptions, cleaner, consistent, and backward-safe.