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

[pyedpiper]

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

[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.

[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.

[pyedpiper]

true but it seems that the performance gap is pretty huge and the new f-strings actually come in on top for string substitution:

https://cito.github.io/blog/f-strings/

[jxub]

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

[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?

[mailslot]

Thanks! I didn't know I had literal string interpolation available until today!