HN Explorer

Python f-strings are the best syntax sugar i never knew about

15 points by pyedpiper ↗ HN
I've written `"text {foo}".format(foo=foo)` so many times I've almost convinced myself that it's not that verbose. Then i discovered fstrings introduced ins 3.6: ``` >>> f"text {fpp}" 'text foo' ``` >>> mind == blown True

13 comments

[ 3.7 ms ] story [ 41.5 ms ] thread
mailslot
Thanks! I didn't know I had literal string interpolation available until today!
dozzie
Ah yes, the thing we had in shell, Perl, and Ruby since forever, and that was never a very good idea.
odonnellryan
Why wasn't it a good idea in these languages?
dozzie
Because it's often hard to edit (which includes quoting or decoding where computation or variable starts) and because it mixes formatting and presenting data with computation.
tedmiston
You can do cool nested calls with them too.

    >>> class A:
    ...     def __init__(self):
    ...         self.foo = 5
    ...     def bar(self):
    ...         return 'cake'
    ...
    >>> a = A()
    >>> f'{a.foo}'
    '5'
    >>> f'{a.bar()}'
    'cake'

    >>> x = {'b': 1, 'c': 2}
    >>> f"{x['b']}"
    '1'
tudelo
Interesting. Thanks for the post. I always just concatenated them out of laziness, and this looks even lazier.
odonnellryan
It's super nice when you're working on reporting software: software that needs to quickly shoot out a string like this from time-to-time!

It's much nicer to write this:

f"{account_name} {pretty_date(start_date)} - {pretty_date(end_date)} account attribution"

and MUCH easier to maintain than the alternative...!

pyedpiper
saw this after posting, so epicly useful. Alreadying thinking of some nice concise, explanatory custom Exception descriptions..
in9
it is very very true. F-strings are awesome. But there is one use case that I prefer .format(), and is when formatting a string using a dictionary. Being able to is awesome:

  some_long_string_template.format(**some_dictionary_with_many_keys)
For me that is such a nice and practical use case. But yes for not many local variables, f-string is the way to go.
EnderMB
I've only recently started learning Python, and the f-strings remind me a bit of the syntactic sugar provided by C# for string.Format() (var str = $"Hello, my name is {name}."; // for those who care)

I get the same feeling as well, and it's something I noticed a lot when it was a new feature to C#. Suddenly, everyone abandoned string.Format() in favour of $"", even when the code would lose a lot of readability.

Syntactic sugar is good and all, but I find it better to be more verbose for the sake of clarity.

kristoff_it
Templated strings are great for when, as the name suggests, you want to create a string with some placeholders to be expanded at a later time.

When you just want to interpolate a string on the fly, Fstrings are absolutely the right thing to do most of the time.

jxub
You could also do: "text {}".format(foo) Works in Python 3.5 and earlier ones too.