3.5 → 3.6 - Upgrading to F-Strings

00:00 The previous lesson covered Python 3.4 and showed you the Enum class and the pathlib module. This lesson covers Python 3.5 and 3.6 and goes into details of f-strings and the ability to use underscores in numeric literals as thousands separators.

00:18 So Python 3.5 in 2015 added the async and await syntax. So now coroutines are part of the language syntax. Again, this is an alternative to threads for concurrency.

00:31 Along with that, in Python 3.5 is the introduction of the typing module for type hints inside of Python.

00:39 Again, this is one of these things that I had a big question about when I looked at some deeper Python code. So along with creating my tutorial about decorators, I created one about typing from Geir Arne here about Python type checking.

00:52 I wrote this title because that’s how I felt about 3.6. It felt like the world had finally gone to Python 3 by this point. But after writing the title, I stopped to try and think about why I felt that way and came to the conclusion that this is probably just when I gave up supporting 2.7 in my own libraries.

01:09 So take the title with a grain of salt. It could just be read as when I started using it. So ego center of the universe and all that. Anyhow, this release did have a big feature that I liked a lot.

01:20 In fact, it might have been why I switched to it. F-strings. I’ve never been a fan of the str.format() method. I tended to stick with the old school C style instead.

01:29 But f-strings definitely make for easier-to-read code. And here is another one of those features I didn’t learn about until much later, using underscores in numbers for thousands separators.

01:40 Sometimes the little things are what make your code easier to read. And speaking of easier, yeah, generators and comprehensions are complicated enough topics without making them asynchronous.

01:51 But well, as of 3.6, you could. Let’s head to the REPL for a quick tour of f-strings.

01:59 An f-string is a way of creating a string that includes values from your code. So first I need a value

02:05 or two. For my American friends, that’s in meters. That’s actually a big dog, not a really, really tiny one.

02:16 By putting an f prefix on a string, I can reference a variable inside of it through the use of brace brackets. What’s inside of those brackets is known as a field. File that bit of knowledge away for later.

02:27 When you discover f-strings, in this example, the .format() field gets replaced with the contents of the .name value giving me the resulting string.

02:39 The contents of fields in an f-string get converted to strings, so I can have floats in them as well. What, though, if I want to change the format of the float?

02:52 That’s what format specifiers are for. The bit after the colon in the height field says that I want two decimal places for this float and a leading zero. Before demonstrating a bit more, I’ve got a tangent to cover those underscores in numbers things I was talking about.

03:08 Let’s say I want to express my dog’s height in nanometers. For my American friends, the beauty of metric is converting between values typically means multiplying or dividing by a thousand, whatever.

03:20 How many hog heads to the furlong are you getting in your car? Right.

03:26 Meters to millimeters is a thousand, to micrometers is another thousand, then a final thousand to get to nanometers. The end result is that very large number.

03:35 The problem with very large numbers is it’s easy to miscount how many zeros are in them and be off by a factor of 10 or more, which is why when humans write these numbers, they often include a thousand separator. In North America, that’s a comma. Offer not valid in Quebec. See, that’s funny if you’re Canadian, as that’s written in the fine print of pretty much every single contest. Commas and decimals are meaningful in Python.

03:59 So instead, the underscore makes that far more readable. Now I can be sure that this is 900 million.

04:10 Unfortunately, the REPL doesn’t include them when you evaluate it, but it does make constants clearer in your code. Okay, that was my underscore tangent. Let’s get back to f-strings.

04:24 This time, I’ve put some asterisks around our value. You’ll see why in a second.

04:32 Format specifiers can be used with strings as well. Here they’re used for padding. As you can see by the asterisks in the output, the result is a 10 character field filled with spaces.

04:47 The addition of a greater than sign right justifies the results.

04:55 By default, it left justifies. But if you want to pad with something other than spaces, you give the padding character and a less than sign in order to be explicit.

05:09 You can also center the fields through the use of the caret. Yeah, this is exactly where I started. In fact, one of the first things I did as I was digging into Python is I wanted to share f-strings with my coworkers.

05:22 Because I thought they were such a useful function as far as working inside of it. I, again, was working with a lot of text in a marketing department dealing with, you know, files coming from databases and so forth like that.

05:34 So I felt like this was going to be a really useful feature and it was nice that this is right when I stepped in. Did you use the format or the C style at all, or this is you out of the gate?

05:44 You started with f-strings? I started with f-strings and I didn’t look back outside of doing a course about it and having to explain what it used to be like and going ugh.

05:53 Right, kind of clunky. Yeah. Yeah. It’s funny how the simple things make a big difference in a programming language. There’s nothing wrong with C style or str.format().

06:04 They’re not much longer than this, but somehow the embedding in this sort of template style is so much easier mentally to sort of go, okay, I know what that is.

06:14 Whereas with the percent desks or curly bracket zero, you’re always sort of going, oh, I gotta look to the end of the line to figure out what’s getting fed into there.

06:22 And oh, is it the third position or the fourth position, particularly with larger strings. Whereas here you’re just reading left to right, like a sentence.

06:28 It’s much, much clearer. I went to a meetup and I was trying to explain to people why I felt this was a a nice enhancement and it took, I think, two meetings for the person to finally go, alright, I did start using them and, and I get it, you know, but like my initial explanation wasn’t like quite hammering it in.

06:47 But again, if you’ve been using something else for a long time, it’s, it’s hard to, you know, see some of the advantages and figuring out how to sell it to them.

06:55 Yeah. And, and that was why I really never went to str.format() was because it didn’t feel like enough of a change to me to warrant getting out of my old ways.

07:03 Right? I’d been doing C style in four different languages, you know, so it was just like muscle memory. It was muscle memory. It’s there. Whereas this actually felt like a step up.

07:14 I found this cheat sheet years ago and it’s my go-to for f-strings. The basics I can remember without a problem, but fancier formatting, like padding and numeric conversions, I don’t always get them right.

07:24 So cheat sheet to the rescue.

07:27 And if you want a deeper dive on f-strings, this course and tutorial at Real Python can help you out. Maybe I should get a little guitar riff sound to go with your links.

07:36 I don’t know, where is there a guitar nearby?

07:44 Next up, Python 3.7 and data classes.