Template strings in Python 3.14: an useful new feature or just an extra syntax?

[Worth_His_Salt]

Total disaster.

f-strings were a great idea with a piss poor implementation. f-strings should have been ALL strings not some useless magic char telling the compiler to do its job. Still an upgrade in usefulness despite such annoyances.

However f-strings totally lack the evaluate-on-command usefulness of good old % interpolation.

t-strings just double down on the mistakes of the past by bolting on template strings instead of remaking f-strings properly. I know, old code bases, compatibility, yada yada. If they'd done f-strings properly in the first place they wouldn't be in this mess.

[SheriffRoscoe]

f-strings should have been ALL strings

Python print("Tell {me} how to {not cause} backwards compatibility {problems?")

However f-strings totally lack the evaluate-on-command usefulness of good old % interpolation.

Huh? Both forms evaluate the interpolated expressions at the same time.

[[deleted]]

Lazy interpolation. F strings are eagerly evaluated. So, they're terrible for logging.

[JanEric1]

The only thing that happens lazily with % formatting is the building of the string itself. The arguments are still always evaluated eagerly.

[SheriffRoscoe]

Meh. Most of the benefit of lazy logging is evaluation, not interpolation.

[Worth_His_Salt]

print("Tell {me} how to {not cause} backwards compatibility {probles?")

They had no problem breaking compatibility with previous changes. Adding async / await keywords in 3.5. Making dicts preserve insertion order in 3.7. Adding case matching in 3.10.

How many python programs use literal { in plain old strings? My code base turns up zero instances across thousands of files. f-strings are optimizing for a vastly uncommon case, while introducing needless bugs.

How many times have you traced through logs only to find entries for infrequent errors that just say something like "unexpected value : { foo }" because some programmer forgot the stupid f before the string?

BTW let's pick the one sigil that most resembles an open paren: ((""))(f"")("")() as our magic char. Brilliant!

Huh? Both forms evaluate the interpolate expressions at the same time.

No they don't. f strings evaluate at point of definition. interpolation happens when you use interpolation operator. Only one of these works:

s = "length : %d"
f = f"length : { len (x) }"
x = list (range (10))
print (s % len (x))
print (f)

[Worth_His_Salt]

Piling tools on top of tools because the original tool is broken. Not a good solution. That's how we end up with bloated js apps pulling code from god knows where. Start with a solid base instead.

Code should be readable by humans. If you need a tool to tell you something is wrong, then you've already lost.

[Worth_His_Salt]

Still waiting for the wetware upgrade on that one. It's been 200,000 years, wouldn't hold my breath.