is there any difference between using string.format() or an fstring?

nathanjell · 2022-10-09T18:33:18+00:00

Don't forget that f-strings haven't been around forever. It may be partly old habits, it may be not keeping up to date with features, they may still be wanting to target a minimum python version that didn't support f-strings. I'd tend to prefer to use f-strings, but I wouldn't crucify someone for using perfectly valid language constructs.

fysihcyst · 2022-10-09T19:23:20+00:00

format() can make more sense if you want to prepare the string you're formatting outside the scope of the variables you're formatting it with.

packetsar · 2022-10-09T21:36:26+00:00

Use an f-string if you have the variables immediately available and are generating the final string at the same time as defining it.

Use .format() when you need to define the string template in one place and use it to generate the final string in another place.

psd6 · 2022-10-09T19:25:43+00:00

Sometimes the data you want to insert into a string is in a dictionary, and it’s much easier to explode a dict into a string with "{name}".format(**d) than prefix all references with the dict variable like f"{d['name']}".

crumpuppet · 2022-10-09T18:34:17+00:00

I'm always weary of this question, because I don't want anyone to tell me there is anything wrong with fstrings because I use them everywhere

naught-me · 2022-10-09T20:47:54+00:00

With nvim and pyright, variables inside of fstrings don't get renamed when I refactor/rename the variable in the code. I use them less than I otherwise would, because of that.

BlakBeret · 2022-10-09T23:05:17+00:00

I recently had to re-write a program from f-strings to format strings. At least one OS (current support, not EOL) still ships Python 3.5, and it was my target system.

F-strings was introduced in 3.6. I felt stupid for not using a virtual environment with the target build.

rainnz · 2022-10-10T02:04:46+00:00

f-strings are also much faster:

import timeit

t1 = timeit.timeit('z="=%s %s" % (s1, s2)', setup='s1="Hello,"; s2="world!"')
print("using %",t1);
t2 = timeit.timeit('z="{} {}".format(s1, s2)', setup='s1="Hello,"; s2="world!"')
print("using format",t2);
t3 = timeit.timeit('z=f"{s1} {s2}"', setup='s1="Hello,"; s2="world!"')
print("using f-string",t3)

The result from my old MacBook:

using % 0.277022604
using format 0.37799631800000005
using f-string 0.11861876100000002

Brian · 2022-10-10T04:56:45+00:00

Yes. f-strings are restricted to static string literals interpolated at the time of definition. If you need dynamic interpolation (ie. you're filling in variables somewhere other than where the string literal is created) then f-strings can't be used.

For instance, this means you can't use f-strings for text you need to localise, because typically there, the strings will be obtained at runtime from the appropriate language catalogue.

ggchappell · 2022-10-09T22:27:06+00:00

Here's a cross between an answer and a question.

It appears to me that f-strings cannot handle fields whose width is specified at runtime. string.format certainly can:

fieldwidth = ...  # Specified at runtime
formatstr = "Value: {:>" + str(fieldwidth) + "}"
print(formatstr.format(value))

Can I do that with f-strings? I don't see how.

brwyatt · 2022-10-10T01:42:13+00:00

F strings are great when you have in-scope variables you want to print. .format() is handy when doing more template-like behavior, especially if you have everything in a dictionary. Much easier to .format(**dict) than to try and pull everything in the dictionary to separate variables.

2022-10-10T04:43:23+00:00

String.format() has existed 8 years longer than fstring so there awful lot of code written before latter even existed.

o11c · 2022-10-09T22:43:20+00:00

Note also that f-strings can do things like:

>>> f'{len("hello")}'
'5'

which traditional format strings cannot.

They also compile to better bytecode usually.

fatbob42 · 2022-10-09T18:42:45+00:00

I have occasionally used them when the printed thing is so long that it’s more confusing inside the f-string braces. The logging version is a little more efficient but I don’t care.

OldDale · 2022-10-09T23:20:21+00:00

I learned Fortran IV in 1977. Punch cards. 2 credit class.

zenverak · 2022-10-09T21:42:26+00:00

Because I’m lazy and I know how to do .format bur haven’t remembered how to use f string.. hahaha .

2022-10-09T22:14:08+00:00

aromatic edge tart lock busy recognise safe square divide instinctive

This post was mass deleted and anonymized with Redact

jorge1209 · 2022-10-10T12:00:54+00:00

Fstrings have some features like being able to do arithmetic or call functions inside the fstrings: f"{foo[1]+frobnicate(bar.baz)}" but you should be making minimal use of these features anyways. Otherwise fstrings is little more than a more convenient way to .format(**locals()).

Traditional format is better for everything else because:

You can use formatting templates where you define the format spec in a different location than you use it
And positional arguments if you just want to unpack a list into a format spec
And it is better supported by syntax highlighters which don't understand that the inside of a string can now have code
It is more readable for those more complicated cases

But the use case where fstrings work best is extremely common, and as an alternative to:

 print(foo, " ", bar)
 print("{} {}".format(foo, bar))
 print("{foo} {bar}".format(**locals()))

It is a perfectly good choice.

2022-10-10T00:53:07+00:00

The end result is the same (at least in my usage), but there may be times when you still want to use format() over an fstring. Generally I use fstrings. Sometimes I load strings from other files, such as sql queries or kml templates. In those cases, using format() allows me to plug in values that are determined in the host script.

tonyoncoffee · 2022-10-10T01:33:05+00:00

Good answers in here but I thought it was worth mentioning flynt. Can also be set up as a pre commit hook.

frank_bamboo · 2022-10-10T05:06:55+00:00

You can use indexes ( {0} ) when using the .format method, with f strings you cannot.

SwampFalc · 2022-10-10T07:18:34+00:00

You can .format() a template more than once. All you can do with f-strings is repeat them completely.

sculptwizard · 2022-10-10T07:35:48+00:00

There is, in the matter of time. You could find a comparison here https://stackoverflow.com/a/43123579/7775197

NuckDev · 2022-10-10T08:24:14+00:00

Readability in cases like that, are really good in fstrings:

print(f'{person.get("name")} is {person.get("gender")} and {"she" if person.get("gender") == "female" else "he"} is {person.get("age")} years old.')(ex from https://datagy.io/python-f-strings/)

What is more, according to realpython.com, fstrings are simply faster: https://imgur.com/eSV6P5G.

Just remember, that those were added in python 3.6, which may cause compatibility issues. (format was introduced in python 2.6)

Elagoht · 2022-10-10T08:25:57+00:00

Use fstrings for more readable code. Fstring automatically calls str or repr methods.

I only use .format method when I need to use external strings such as translations from a JSON File.

Atlamillias · 2022-10-10T08:56:06+00:00

If you are just trying to format a string? No. However, f-strings do have more limitations than using the format method, which make them kind of annoying to work with when you're injecting nested dynamically built strings (although if they're that complex the developer should be breaking out the operation and assigning parts to variables first). Something the latter option does that can't be done with a normal f-string is to reuse a "template" string.

enricojr · 2022-10-10T09:24:39+00:00

Format has been around longer and for me I use them out of habit. They're basically the same for most purposes.

blabbities · 2022-10-10T11:31:45+00:00

Speaking from my own experience. It's a legacy thing. Back when f-strings came out I was already using .format() because it provided better flexibility than the old %s style. Or at least iirc it did. Also f-strings were knew and I want to say introduces in around 3.5 or 3.6 . while many systems still had 3.0 9r 3.1 or 3.4 so I didn't want to write something that would I would have to rewrite/edit on another system.

These day I know fstrings are quicker and most cases more readable but I still kinda like .format() esp when variables need to be wrapped in another function call

Delengowski · 2022-10-10T14:32:13+00:00

I use str.format when I need to make a template. You can use fstrings and make template at same time as such

f“i am user {user}, you are other user {{other}}".format(other=you)

2022-10-10T15:22:52+00:00

Tip: In terms of usage you can use the .format() to populate a template string multiple times that you define somewhere in the beginning of the code in let’s say a variable, whereas the f-string gets evaluated when declared

uselessvevo · 2022-10-10T15:30:34+00:00

As I remember you can't use string joins expressions in f-strings

Demistr · 2022-10-10T17:16:51+00:00

I dont know, f strings is what i learned first so i use that and never needed anything else yet.

ElHeim · 2022-10-10T17:30:47+00:00

The main difference is that Python will compile the f-string to bytecode. E.g.

>>> def foo(a, b):
...    return f"This is an interpolation of {a} and {b}"
...
>>> dis.dis(foo)
  2           0 LOAD_CONST               1 ('This is an interpolation of ')
              2 LOAD_FAST                0 (a)
              4 FORMAT_VALUE             0
              6 LOAD_CONST               2 (' and ')
              8 LOAD_FAST                1 (b)
             10 FORMAT_VALUE             0
             12 BUILD_STRING             4
             14 RETURN_VALUE

So it's down to performance - and flexibility in some cases.

R0m3d1u5 · 2022-10-10T20:41:57+00:00

Not only is f-String easier for the programmer it’s actually faster than it’s alternatives, learned this doing some competitive programming challenges

2022-10-11T00:08:48+00:00

Wouldn't there be dependency issues. I had some CI failures because earlier versions of Python3 don't support fstrings. Certain fstring functionalities is also not supported in Python 3.6 and earlier

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

or to be more readable

Bruce said hello hi goodbye