Python 3, an Illustrated Tour Transcripts
Chapter: Type Annotations
Lecture: The Typing library

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Python 3.5 introduced a typing library. This is in the standard library and it adds support for various types.
0:08 We can get support for any, union, tuple, callable, type variable and generic.
0:13 There's also other types that allows us to specify dictionary and list types and we'll see some examples of those.
0:20 Another thing to be aware of is if you've got a class that you're saying this variable is going to be a type this class
0:26 and the class is in the same file as you're referencing it, but the class has not been defined yet, it's going to be defind later,
0:32 you can just put the class name in a quoted string for a forward declaration of that class. Here's some examples of annotations
0:39 note that I am using the typing library here and I'm importing capital Dict here, and here in my annotation,
0:45 I've got a variable called ages and it's mapping a name to an age. So here's my traditional dictionary over on this side here
0:53 Fred has the age of 10, and here's my annotation here. I'm saying dict and then I put square braces here and then I map the key and the value here.
1:06 So string here is the key and it is the value. What this allows me to do is specify what the type,
1:14 the specific type of the key is and what the specific type of the value is. Again, I'm going to harp on this but when you run your code
1:22 Python is going to ignore this, you need to use a tool like mypy to actually get some information out of this, we'll show an example of that later.
1:29 If you've got a list of items here in square brackets in our annotation list the list type that we import from typing, note that it's capital List,
1:37 we see that we are putting strings into our list. So this allows us to type our list and use a specific type in there.
1:46 Same thing for tuples we can specify a tuple, we're going to import capital tuple from the typing.
1:52 And in this case we're saying a person has a string, an int and a string. And so those correspond to the individual items in the tuple.
2:01 So Fred is a string, 10 is an integer, and USA is a string. We can also specify types for callables,
2:09 here, I have a little function called repeat that takes a function as input, again, Python has first class functions
2:15 and I can invoke my function down here, I can pass my function around and I can return functions and pass in functions to other functions.
2:23 And we can say that this function that's getting passed into repeat is going to be a callable. We're going to import callable from typing
2:31 and here in the square brackets inside of the square brackets, these are the parameters that are passed into our callable
2:37 and then this final guy here at the end is the return value here. So this callable that's passed in, if we're passing in add
2:43 it takes two integers and it returns an integer as output. One thing to notice, pep 526 provided some syntax for typing variables,
2:52 but it didn't provide syntax for all the variables that can get created in Python, when you use a with statement and use an as at the end
3:01 it creates a variable called foo and when you use a for loop and you put variables in there, it's going to create x and y.
3:08 Pep 526 does not have a way to inline those type annotations there but pep 484 did by providing these comments here.
3:17 So if I've got a with statement I can put a little type comment at the end that says foo is going to be type int.
3:24 Similarly, for a for loop, if I want to put a type on those I can put a type there that says x is going to be a float
3:31 and y is going to be a float as well. This is straight out of the pep 484. The typing module also has support for typing generators.
3:39 If I want to type a generator, I can just say this echo_round returns a generator and this first guy here, this is going to be whatever it yields.
3:48 So we can see that we're yielding round res, which is an integer. The second value that's getting past here, float is the send_type
3:56 so we can see that when we get input into it, it is going to be a float or it should be a float and we're going to round it,
4:03 so what comes in should be a float and then this final one here is the return type. So the string that we're returning is going to be a string.
4:14 So that's how you use the generator type annotation.

Talk Python's Mastodon Michael Kennedy's Mastodon