
Python f-strings are the best syntax sugar i never knew about - pyedpiper
I&#x27;ve written `&quot;text {foo}&quot;.format(foo=foo)` so many times I&#x27;ve almost convinced myself that it&#x27;s not that verbose. Then i discovered fstrings introduced ins 3.6:
```
&gt;&gt;&gt; f&quot;text {fpp}&quot;
&#x27;text foo&#x27;
```
&gt;&gt;&gt; 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.

~~~
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...!

------
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/](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?

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

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

