What I love f-strings for the most is padding my strings. Not only can I do a left align or right align, I can also do a center align, and give it a particular padding character. x = 'test' f'{x:>10}' → ' test' f'{x:*

Also, if you use "%" instead of "f" in the float formatting, it will calculate the percentage and add a "%" at the end. For example: >>> x = 1/3 >>> print(f"{x = :.2%}") x = 33.33%

i love how fstring can convert between bases really easily: >>> a = 42 >>> f"{a:x}" # hex '2a' >>> f"{a:X}" # hex (uppercase) '2A' >>> f"{a:b}" # binary '101010' >>> f"{a:c}" # ascii '*' >>> f"{a:o}" # octal '52' >>> f"{a:010b}" # combined with padding '0000101010'

4:44 this is useful when you are interfacing with an old system that doesn't support utf-8

I've learned more about f-strings from this video (and comments!) than from the intro documentation. Nice job.

Thanks James, this video was really interesting! I’m currently designing a really basic beginner python course for a local high school and your videos are definitely a source of inspiration. Keep up the great work :)

Wow nice, I just saw the part with {x=} recently in one of your videos and was using it already quite a lot since. Amazing you made a whole video about it

All these were useful but the equals sign trick at the beginning will save me SO much time I immediately thought wow that's amazing for debugging and then you said the same thing right after. Thank you!

Great video as always! Keep it up! Really love the informal feel in this one, a lot like your earlier vids.

You rock!! Just changed the way I write code going forward. Man I love this channel, love this info.

This is the best Python YT channel for tips and tricks. Glad I found it! EDIT: Another thing I learned recently is that you can pass the spaces you want to add between strings inside of the curly brackets. Example: f"{variable1:{10}} {variable2:{10}} {variable3}" That will add a 10 characters limit for variable1 and variable2, so everything looks properly formatted.

I can not get over the 'dunder' phrase. All I can think of is The Office.

f strings are my favorite addition to python since I've started using it.

This was such a useful and awesome video! I love f-strings so this is super useful to know about. Thanks!

I often use f-strings to tabulate my data...and this tabulation helps when I am trying not to use library for the purpose. f'{something:50}{another_one:5}' like this!

Thank you for saving a few days of my life that I would've spent on debugging

Always learning. First time I saw __format__ used and it makes sense. That's all top of the great f-string tips you had. Thanks!

Interesting. I did not know the additional possibilities of f-string. Thanks for pointing them out and give me a reason to revisit the python f-string page. Maybe there are further interesting ideas for how to improve my programming.

print(f' Start Price {sp:.9f}. Current Price {cp:.9f}. Change {per:.2f}%.') Thanks For the tip this makes my life much better, Also i just found you and you introduced me to dataclasses dataclass making you my new favorite person :D

Great video as always - In light of debugging, a great module I’ve been using is “icecream” - high recommend, it has the similar effect to the equals within the f-string.

F-string is essentially like F-word, very very cool language feature.

"Good for debugging", you said the same thing I was thinking.

Another home run video. I learned about {a=} and __format__(). Very useful, thanks!

Good vid, would like to add that you can now add thousands separators to numbers you print by doing: print(f'{num:,}') gives you something like 1,000,000

For f-strings,when you use the walrus operator(for whatever reason) you have to put parentheses around the expression for it to work.

Nice video, i learned a lot !

Loooove f-strings, love the vid, love the channel 🤠

basically, you can use the formating for types in fstring as it was used with .format for previous versions of python, but the advantage is that fstring is a little faster. more information can be found in PEP 498 -- Literal String Interpolation.

A new mCoding video makes my day!

3:32 I recommend holding down ctrl when erasing or jumping over a word, it's really useful!

I knew of the equals sign thing, but the rest was fascinating, thanks!

the = sign after the string blew my mind haha Thanks!

Wow. lot of functionalities packed!

I've been looking for the wrapper thing for days thanks

Cool! I do like the more informal style thanks

Didn't know you could do this with f-strings, good video :)

This is really awesome stuff, thanks for sharing it!

This video is soooo much helpful... So glad I found your channel😄😄

Fantastic video, love these fundamentals

The date formatting is an amazing trick, thanks

Awesome work Loved it!

Again learnd a lot in 9:09 min, thy -great channel

f'{val =}' has been very very useful, thank you!!!

Great job! Your videos are excellent. I enjoy them a lot.

Thank. You so much for all these

Cool tips. Thanks!

Everytime I think I have a handle on Python, you burst my bubble with something new

Even tho I never use python, I still enjoy watching your videos))

ascii() is useful for identifying Unicode "confusables", like the Cyrillic "A". >>> 'А' == 'A' False >>> print(ascii("'А' == 'A'")) "'\u0410' == 'A'"

The most useful one for me is ‘!a’ since it will allow me to fine the unicode/short code so the user or I can use it for some functions or features that may not work well with the actual emoji

Saw the title, thought "huh, what else could there possibly be". Needless to say I learned some useful things

Amazing! Didn't know half of that!

Nice video. Did you forget to talk about nested formatting in the end?

This little *f"{var=}"* trick is GOLD!!

I have long loved f-strings, but I never knew how cool they *actually* are. This is great, thanks! Any chance you're working on a video about the @overload decorator? I have been very confused about the documentation I've read and knowing your style, I think you could explain it really well!

Spooky magic fstrings (great video!)

Great video. Thanks!

I took a hiatus from python from about 2017 to just recently and lord do I love this things

geez this is actually useful. i would always write __repr__ methods like ` return f"classname('value1={self.value1},'value2'={self.value2})" ` the equals would make this so much easier

4:44 this is useful when you are using CircuitPython on a microcontroller and driving an LCD display that doesn’t support Unicode

Grateful, very useful

1:02 is exactly what I’ve been looking for!!

Blown away. How did you come across this stuff?

To all of you, the printf function from stdio.h in C has so many of these things too. You would be surprised.

Thanks so much for going over these f-string features. Very concise video 😊🙏😊🙏

Really the best feature in Python 3, finally no need to use the format function.

At around 5:10, you said !s would be the default. I played around a bit and found that this is not quite correct. What seems to happen under the hood is that the curly braces around an expression "return" something like format(bangfunc(expression), format_spec), where bangfunc is indeed determined by the char after the bang. But if the bang is absent, bangfunc "defaults to the identity" and NOT to str. format_spec is the plaintext after the colon as a string and defaults to an empty string if the colon is absent. As the outer function, format will always call type(bangfunc(expr)).__format__, which only equals type(expr).__format__ IF the bang is absent. Therefore, the format_spec must fit to the type of what bangfunc returns to avoid raising an exception. So the reason why {expr} and {expr!s} behave the same in most cases is NOT because they do the same thing: for {expr}, bangfunc will be irrelevant because no bang is specified. format will then be called on expr with an empty format_spec. If type(expr) or one of its user-defined bases had defined __format__, it might do arbitrary stuff, but if not, object.__format__(expr, "") will just return str(expr). for {expr!s}, str is the bangfunc, so first, str(expr) will be called, which returns a string, lets call it 'stri. THEN format will be called as str.__format__(stri, ""), which defaults to returning stri itself. So basically, {expr} and {expr!s} will in general not behave the same as soon as the class of the object returned by the expression uses a __format__ that does not behave like __str__ if the format_spec argument is an empty string. I'm aware that these are unrealistic edge cases, but investigating this provided an even deeper understanding for me of how fstrings, format, str and repr are related and implemented.

I sometimes use f-strings to print results of a process to a file, it's like a cheats way of sending data to a CSV file. I imagine it isn't efficient, but it does the job when you don't have much data, but want to use the output file to check results.

i watched this for fun but it actually helped I was writing a programing language in python so it is very text based

nicely explained

I would have liked to have seen an example using bang s and dunder format at the same time, since you said the point of it was that it does its thing before the format codes. Still, great video!

WOW great video! using f-strings ------------------------- age = 21 def p(val): print(f'{val=}') p(age) -------------------------- it's possible to show up the argument (age = 21) instead, the parameter (val = 21)

Beautiful

Thanks, mate, I subbed.

yess, this is exactly what was separating me from being an Ultra programmer! a good video btw :)

I was so excided when I learned about f-strings while skimming the notes on the 3.6 release. I may or may not have gone into all my code and replaced every format() I could find.

Oh my god thank you!!

extra nice !

Repr is useful when using print for debugging and logs

I waited for this!!!!

Thanks a lot for the very interesting video! I was wondering, what would be the use case of writing a __format__ method instead of a __repr__ one within a custom class?

So wtf is the encoding of the hex string in !a? Presumably the unicode code point or its internal encoding? Regardless, its useful figuring out what character was actually received when you can't really tell by looking, e.g. Because your console can't display it or it looks similar to another character (X vs Greek chi, etc)

great video thanks

How do you format all floats deep inside a list or a dict, for example, to two decimal places?

love it!

I'm gonna find "!s" really useful. I often have integers in my f-strings, and then I want to use the format-modifiers to modify the resulting strings (usually to left-pad the number with spaces or with zeros) I've been writing a lot of code like `f"{str(my_num):

Caveat: {equal_sign=} ignores escape characters such as For an example: >>> foo 'stuff and things' >>> print(f"{foo}") stuff and things >>> print(f"{foo=}") foo='stuff and things'

That = trick would be really handy.

I fall asleep to these videos 👍 cured my insomnia 👍

For anyone interested, string interpolation is documented in Python's *PEP-498* Here's a question / answer pair to research how fstrings are implemented in Python's source: _comments block links so at stackoverflow-dot-com:_ */questions/56635686/how-where-are-fstrings-implemented*

Is there a specific reason why you use single quotes when print()'ing but double quotes when setting variables / returning strings?

!a could be super useful trying to debug input - including string values pasted into the code - to figure out that instead of the printable character you expected, it’s some Unicode nonsense like the double dash or fancy double quote character. Generally finding the rogue character means piping the script output to hexdump to see that you have printable ascii values surrounding some weird looking multibyte sequence that doesn’t make sense like x41 x81 xe0 x43 (made up Unicode value, no idea what it is) You can try to string compare that to “ABC” all day long. It might render visually like “ABC” but it’s not ascii ABC. Can see !a as a useful tool here.

f strings is one of my favourite things in python

Thx!

This is gold

I'm looking for a way to teach f-strings to use locale. I get from print(f'{1400.0:,.2f}') -> 1,400.00 but I haven't found a way to get something like the German format 1.400,00 through configuration. Of course, I can create the string myself using the locale module, but that means changing all f-strings. Anyone have a suggestion/link?

Don't forget that the "f" prefix also works with triple-quoted string.

Every time I think I know Python, I find something I had no clue about.

You can not only nest f-strings but also make a whole table with one. Think about `a=f"{{}*3}"` and now is the question of what happens when you have something like `b=[0,2,4]` and then `a.format(*b)` Also f-strings can be used outside of print statements. Great for concatenating stuff.

Thanks