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%
@@felipevasconcelos6736 _That_ is an interesting question. Numpy is int 2-36, but *Google* _"Numeral systems with non-integer bases"_ and (Reddit thread) there are several examples in the comments (e.g.): ~ Phinary (golden ratio base) ~ refs to Knuth's The Art of Computer Programming (negative and irrational bases), ~ quater-imaginary (base 2i) ~ a link that has Wolfram Alpha do a non-integer base ...hope that helps.
@@definesigint2823 there’s a TH-cam channel called imaginarybinary that showcases a different flavor of base 2i. It’s criminally underrated, last time I checked the whole channel had one comment, and it was mine.
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 think by "limit" you mean "minimum". It looks like this is the equivalent of f"{variable1:10} {variable2:10} {variable3}" (without the curly braces).
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 :)
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!
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.
Firstly i commend you for this investigation and for taking the time to present your findings. Indeed, my explanation covers only the simple case and excludes discussion of these edge cases which I think are uncommon in real code. Indeed, practically every explanatory video I make could be wrong if the user decided to modify a metaclass, change an element of the builtins module, or use a C extension module because Python is so dynamic. I'll still try to keep things to the most common useful cases on screen, but I'm glad your comment is here for people that want to understand more as you have done. Keep up your inquisitive nature, it will take you far!
@@mCoding Thanks for your kind reply! I really enjoy your videos, it often feels like you manage to see the whole language as just one big picture, with all its countless interactions of which you never lose track or misinterpret since you truly understand what they're built upon. And therefore you know exactly what causes the most headaches for people who only have a shallow understanding of whats going on. I feel like many developers never achieved this or even tried to, because they only see the language as a tool they have to handle "just good enough" and it stays more like countless mosaics loosely glued together, with many links missing, rather than eventually becoming that big picture. I also aim for that big picture in everything I try to learn, since only then the process feels satisfying. I guess the inquisitive nature goes hand in hand with that "restriction" :) Also, one of the main reasons why I switched to software development after achieving my physics degree was because "trying out stuff" felt so much faster, which in my opinion is a crucial element for limitless self education. Anyway, keep up that great work!
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
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!
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
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.
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
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.
yeah, but not in a good way, I don't like it. it seems like jargon. so you have this whole language that can't stand Curly brackets because it looks not like natural language text. Yet then it starts using __init__ instead of the word constructor or Initialize or even just init or con. same with Decorators why @ when it should be dec or "dec nameofdec:" then indented "def thefunctoDec():" or "dec nameofdec(def functodec())", or just "nameofdec(def thefunctoDec():)" these would make it easier to guess out what a Decorators is doing, if you have never seen it. the Decorator looks like a function that is taking in this function I define. it's kind of like a the same as a lambda but bigger. pythonic only cares about readability when you do something complex, but if you talk about getting rid of their jargon syntax sugar to make things more readable they complain about their fingers breaking from extra typing. personalty I find Curly brackets more readable because you are not depending on unseen spaces but I understand they are not to python's style. just saying dunder __ __ has never seemed pythonic and should be replaced. even if it breaks old code because python does not care about breaking old code, it's why python 2 still is a thing.
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)
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!
I vaguely remember using it in one of my previous videos already... but which one I don't remember. Taking a break on typing related content for a while, python people didn't seem to like it as much.
@@mCoding I vaguely remember something about it too; I'll take a look and see if I can find it. I look forward to whatever you work on next, whether its Python or not, you have a tendency to make interesting and educational content!
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
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.
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*
I briefly mention this difference in the video. This is because f'{foo}' uses the str of foo, whereas f'{foo=}' uses the repr of foo. The repr of a str shows escaped characters, so that explains it!
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
!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.
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.
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.
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):
print(f"{(new_variable := 'whatever you want to assign to new_variable') = }") >>> (new_variable := 'whatever you want to assign to new_variable') = 'whatever you want to assign to new_variable' print(f"{(now := datetime.now()): %y-%m-%d}") >>> 22-05-15 ^ these actually work. I don't know how or why I would ever use assignment expressions in f-strings but I am now determined to include it _somewhere_ in my code.
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.
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)
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?
I looked at the github and still can't understand the purpose of !s. At 5:20, it's mentioned its for when you want to chain formatting operators behind. Can anyone show some code examples of how !s makes formatting operators possible that is otherwise impossible without it?
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!
f’str_value!a’ this case needed for see how string would look like in URL. In URL all non-ASCII symbols will convert to smth like this /U73937489. This is my Thought 😀
URL encoding is a lot different. Every illegal character is encoded as UTF-8 and the bytes listed in hex after a %, or in the case of “--xn” encoding, some complex stuff that I can’t really explain.
Isn't this a bit too obfuscated when there would be more clear ways to get the same kind of result by just concatenating strings and functions with the + sign?
Good question! Well, there is a big performance difference between using + and using f-strings, f-strings are notably faster because every + you use creates a copy of the text. However, even for readability I think most people would prefer f-strings because otherwise you would end up having to manually convert things to strings if they are not already. For instance, print('program done in ' + str(round(t,2)) + 'seconds.') versus print(f'program done in {t:.2f} seconds.'). Of course, this requires programmers to know what the format strings mean, but they are fairly intuitive once you get the hang of it.
I still remember how I made a large script with lots of logs, formatted with f-strings. Then I uploaded it on a server and subsequently had to replace all of them with explicit 'format' statements because server was running Ubuntu.
This seems like more of a version of Python problem and less an ubuntu problem. Well I suppose you may not have had access to upgrade the Python so I guess that's fair. Always good to keep in mind what software your system has.
@@mCoding I think, it took them almost a year to finally upgrade to python 3.6. But yes, it is a version problem that I encounter pretty frequently with Debian based distros.
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?
You're welcome! Consider the case of a Date object. You would want both a format and repr. The repr might print out something like Date(year=2021, month=9, day=17), but with a format method you could allow users to print it as either 2021/17/09 or 9/17/2021 or or Sept. 9, 2021, or whatever they want. Format method allows the developer to give the user the freedom to print out the class in a variety of different ways.
Why didint you do all of the formatting stuff like alignment and making sure all of ur print statements print the same length even with diffrent variables Eg f"{var:
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:*
most of this information comes from pyformat info, great website
@@Imperial_Squid do it :D
This should have been in the video it's super useful
Also useful for float formatting
Thanks for the tips.
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%
You definitely blew my mind!
Damnnn noice.
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'
I wish I could convert to an arbitrary base just as easily. I use seximal a lot, that would certainly help.
@@felipevasconcelos6736
*numpy.base_repr(my_int, base=6)*
@@definesigint2823, does it work with non-integer bases?
@@felipevasconcelos6736 _That_ is an interesting question. Numpy is int 2-36, but *Google* _"Numeral systems with non-integer bases"_ and (Reddit thread) there are several examples in the comments (e.g.):
~ Phinary (golden ratio base)
~ refs to Knuth's The Art of Computer Programming (negative and irrational bases),
~ quater-imaginary (base 2i)
~ a link that has Wolfram Alpha do a non-integer base
...hope that helps.
@@definesigint2823 there’s a TH-cam channel called imaginarybinary that showcases a different flavor of base 2i. It’s criminally underrated, last time I checked the whole channel had one comment, and it was mine.
I've learned more about f-strings from this video (and comments!) than from the intro documentation. Nice job.
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 think by "limit" you mean "minimum". It looks like this is the equivalent of f"{variable1:10} {variable2:10} {variable3}" (without the curly braces).
4:44 this is useful when you are interfacing with an old system that doesn't support utf-8
I'm very fortunate that I don't have to do this! Thanks for sharing!
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 :)
Awesome! Glad to provide inspiration. Feel free to assign my videos for extra credit 😉
@@mCoding $python3 -c ‘print(“same, you are a very good resource”)’
same, you are a very good resource
$
f strings are my favorite addition to python since I've started using it.
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!
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.
Firstly i commend you for this investigation and for taking the time to present your findings. Indeed, my explanation covers only the simple case and excludes discussion of these edge cases which I think are uncommon in real code. Indeed, practically every explanatory video I make could be wrong if the user decided to modify a metaclass, change an element of the builtins module, or use a C extension module because Python is so dynamic. I'll still try to keep things to the most common useful cases on screen, but I'm glad your comment is here for people that want to understand more as you have done. Keep up your inquisitive nature, it will take you far!
@@mCoding Thanks for your kind reply! I really enjoy your videos, it often feels like you manage to see the whole language as just one big picture, with all its countless interactions of which you never lose track or misinterpret since you truly understand what they're built upon. And therefore you know exactly what causes the most headaches for people who only have a shallow understanding of whats going on. I feel like many developers never achieved this or even tried to, because they only see the language as a tool they have to handle "just good enough" and it stays more like countless mosaics loosely glued together, with many links missing, rather than eventually becoming that big picture.
I also aim for that big picture in everything I try to learn, since only then the process feels satisfying. I guess the inquisitive nature goes hand in hand with that "restriction" :) Also, one of the main reasons why I switched to software development after achieving my physics degree was because "trying out stuff" felt so much faster, which in my opinion is a crucial element for limitless self education.
Anyway, keep up that great work!
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
3:32 I recommend holding down ctrl when erasing or jumping over a word, it's really useful!
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!
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
"Good for debugging", you said the same thing I was thinking.
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.
For f-strings,when you use the walrus operator(for whatever reason) you have to put parentheses around the expression for it to 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
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.
Cool, thanks for sharing!
ascii() is useful for identifying Unicode "confusables", like the Cyrillic "A".
>>> 'А' == 'A'
False
>>> print(ascii("'А' == 'A'"))
"'\u0410' == 'A'"
4:44 this is useful when you are using CircuitPython on a microcontroller and driving an LCD display that doesn’t support Unicode
Or when your using user input that will later be called.. it ensures the application will display it properly
Thank you for saving a few days of my life that I would've spent on debugging
F-string is essentially like F-word, very very cool language feature.
F-string is the closest younger sibling to the g-string
I can not get over the 'dunder' phrase. All I can think of is The Office.
__Mifflin this is Pam.
yeah, but not in a good way, I don't like it. it seems like jargon. so you have this whole language that can't stand Curly brackets because it looks not like natural language text. Yet then it starts using __init__ instead of the word constructor or Initialize or even just init or con. same with Decorators why @ when it should be dec or "dec nameofdec:" then indented "def thefunctoDec():" or "dec nameofdec(def functodec())", or just "nameofdec(def thefunctoDec():)" these would make it easier to guess out what a Decorators is doing, if you have never seen it. the Decorator looks like a function that is taking in this function I define. it's kind of like a the same as a lambda but bigger. pythonic only cares about readability when you do something complex, but if you talk about getting rid of their jargon syntax sugar to make things more readable they complain about their fingers breaking from extra typing. personalty I find Curly brackets more readable because you are not depending on unseen spaces but I understand they are not to python's style. just saying dunder __ __ has never seemed pythonic and should be replaced. even if it breaks old code because python does not care about breaking old code, it's why python 2 still is a thing.
You rock!! Just changed the way I write code going forward. Man I love this channel, love this info.
A new mCoding video makes my day!
And comments like yours make my day!
Nice video, i learned a lot !
Saw the title, thought "huh, what else could there possibly be". Needless to say I learned some useful things
f'{val =}' has been very very useful, thank you!!!
Very welcome 😀
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)
To all of you, the printf function from stdio.h in C has so many of these things too. You would be surprised.
This little *f"{var=}"* trick is GOLD!!
Another home run video. I learned about {a=} and __format__(). Very useful, thanks!
Great video as always! Keep it up! Really love the informal feel in this one, a lot like your earlier vids.
the = sign after the string blew my mind haha
Thanks!
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!
I vaguely remember using it in one of my previous videos already... but which one I don't remember. Taking a break on typing related content for a while, python people didn't seem to like it as much.
@@mCoding I vaguely remember something about it too; I'll take a look and see if I can find it.
I look forward to whatever you work on next, whether its Python or not, you have a tendency to make interesting and educational content!
@@mCoding typing related content is awesome!
though to be fair pretty much all your Python content is awesome ;)
th-cam.com/video/yWzMiaqnpkI/w-d-xo.html
Oh nvm you already found it lol
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
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.
Again learnd a lot in 9:09 min, thy -great channel
I took a hiatus from python from about 2017 to just recently and lord do I love this things
I've been looking for the wrapper thing for days thanks
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*
Everytime I think I have a handle on Python, you burst my bubble with something new
The date formatting is an amazing trick, thanks
I knew of the equals sign thing, but the rest was fascinating, thanks!
This was such a useful and awesome video! I love f-strings so this is super useful to know about. Thanks!
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!
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'
I briefly mention this difference in the video. This is because f'{foo}' uses the str of foo, whereas f'{foo=}' uses the repr of foo. The repr of a str shows escaped characters, so that explains it!
Wow. lot of functionalities packed!
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
Wouldn't that include the `self.` prefix as well though?
!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.
That's a good point, I never thought about that but you're totally right!
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.
Really the best feature in Python 3, finally no need to use the format function.
Loooove f-strings, love the vid, love the channel 🤠
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.
Some terminals don't support unicode, I think that's the main use case of `!a`
Some functions don’t play well with them either so it will help in formatting it for them as well
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):
print(f"{(new_variable := 'whatever you want to assign to new_variable') = }")
>>> (new_variable := 'whatever you want to assign to new_variable') = 'whatever you want to assign to new_variable'
print(f"{(now := datetime.now()): %y-%m-%d}")
>>> 22-05-15
^ these actually work. I don't know how or why I would ever use assignment expressions in f-strings but I am now determined to include it _somewhere_ in my code.
This is really awesome stuff, thanks for sharing it!
My pleasure!
1:02 is exactly what I’ve been looking for!!
Cool! I do like the more informal style thanks
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.
Blown away. How did you come across this stuff?
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)
It’s unicode. I use it for properly displaying emojis
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.
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?
Nice video. Did you forget to talk about nested formatting in the end?
Great job! Your videos are excellent. I enjoy them a lot.
Thank you very much!
I looked at the github and still can't understand the purpose of !s.
At 5:20, it's mentioned its for when you want to chain formatting operators behind.
Can anyone show some code examples of how !s makes formatting operators possible that is otherwise impossible without it?
This video is soooo much helpful...
So glad I found your channel😄😄
I fall asleep to these videos 👍 cured my insomnia 👍
Didn't know you could do this with f-strings, good video :)
Repr is useful when using print for debugging and logs
Awesome work
Loved it!
i watched this for fun but it actually helped I was writing a programing language in python so it is very text based
Fantastic video, love these fundamentals
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!
You can just open doc 2.4.3 and read few paragraphs.
{x=} format was added in 3.8 only
Even tho I never use python, I still enjoy watching your videos))
f strings is one of my favourite things in python
Thank. You so much for all these
Amazing! Didn't know half of that!
Is there a specific reason why you use single quotes when print()'ing but double quotes when setting variables / returning strings?
*You can even use docstrings:*
my_var = """here is a docstring
it can be on multiple lines
and retains spaces..."""
print( f'{my_var}' )
Spooky magic fstrings (great video!)
How do you format all floats deep inside a list or a dict, for example, to two decimal places?
f’str_value!a’ this case needed for see how string would look like in URL. In URL all non-ASCII symbols will convert to smth like this /U73937489.
This is my Thought 😀
URL encoding is a lot different. Every illegal character is encoded as UTF-8 and the bytes listed in hex after a %, or in the case of “--xn” encoding, some complex stuff that I can’t really explain.
Cool tips. Thanks!
f'{str_value=}' especially if persist over function scopes, looks like it has some potential for security issues 🤔
yess, this is exactly what was separating me from being an Ultra programmer!
a good video btw :)
Glad you enjoyed it!
That = trick would be really handy.
What about using this for assignment? Looks like it is actually less work in some cases.
Isn't this a bit too obfuscated when there would be more clear ways to get the same kind of result by just concatenating strings and functions with the + sign?
Good question! Well, there is a big performance difference between using + and using f-strings, f-strings are notably faster because every + you use creates a copy of the text. However, even for readability I think most people would prefer f-strings because otherwise you would end up having to manually convert things to strings if they are not already. For instance, print('program done in ' + str(round(t,2)) + 'seconds.') versus print(f'program done in {t:.2f} seconds.'). Of course, this requires programmers to know what the format strings mean, but they are fairly intuitive once you get the hang of it.
I still remember how I made a large script with lots of logs, formatted with f-strings. Then I uploaded it on a server and subsequently had to replace all of them with explicit 'format' statements because server was running Ubuntu.
This seems like more of a version of Python problem and less an ubuntu problem. Well I suppose you may not have had access to upgrade the Python so I guess that's fair. Always good to keep in mind what software your system has.
@@mCoding I think, it took them almost a year to finally upgrade to python 3.6. But yes, it is a version problem that I encounter pretty frequently with Debian based distros.
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?
You're welcome! Consider the case of a Date object. You would want both a format and repr. The repr might print out something like Date(year=2021, month=9, day=17), but with a format method you could allow users to print it as either 2021/17/09 or 9/17/2021 or or Sept. 9, 2021, or whatever they want. Format method allows the developer to give the user the freedom to print out the class in a variety of different ways.
Why didint you do all of the formatting stuff like alignment and making sure all of ur print statements print the same length even with diffrent variables
Eg f"{var:
I feel like Python is your Girlfriend and you know all the tiny little secrets about it😅
”it”
that's creepy
You think you'll ever get to know all the tiny little secrets of a girlfriend? That's cute... 🤣
...
Also, a bit creepy.
@@Xiph1980 haha yeah
uhh... her? 😂
for the .2f
I don't need Decimal module anymore?!???
should use f'sting in SQL queries? any security issue?
Thanks, mate, I subbed.
Welcome!