Python f-strings are the best syntax sugar i never knew about
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
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'Interesting. Thanks for the post. I always just concatenated them out of laziness, and this looks even lazier.
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...!
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...!
saw this after posting, so epicly useful. Alreadying thinking of some nice concise, explanatory custom Exception descriptions..
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)
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.
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.
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.
When you just want to interpolate a string on the fly, Fstrings are absolutely the right thing to do most of the time.
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/
You could also do:
"text {}".format(foo)
Works in Python 3.5 and earlier ones too.
Ah yes, the thing we had in shell, Perl, and Ruby since forever, and that was
never a very good idea.
Why wasn't it a good idea in these languages?
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.
Thanks! I didn't know I had literal string interpolation available until today!