Type-Checking Python Programs With Type Hints and mypy

Key Takeaways

hey everyone so this is going to be a quick intro to using the mypi type Checker to type check your Python 3 programs um if you're wondering type checking in Python um it's it's kind of a big deal right now A lot of people are talking about how this could potentially be the future of the language and just to give you a feel of of you know what type checking is actually good for so this is a new feature that was added in Python 35 and what it allows you to do is um let's say we write a simple function um let's call it at this and we just give it two arguments A and B and it's going to return a plus b right so in kind of stock python we don't really have a good idea of what the types are that this function deals with and then also what the return the type of the return value is going to be I mean you could imagine that I can call this with uh two strings and I can also call this with two integers and I could call it with a bunch more things and some of them might not even make a lot of sense so what type hinting does now is it allows me to specify the expected types for these arguments and then also for this function so I can say okay you know I expect these two arguments to be integers and then I expect this function to also return an integer and uh the way this works is that these guys here these type annotations they are um a syntax extension that was added to python 3.5 so this is not going to work in older versions of python there's a way to do that in Python 2 as well uh and it invol uh I think it works with some some comment syntax or basically putting these annotations into comments you can look that up on your own um let's for now let's focus on the Python 3 syntax and basically what these typin allow me to do is like specify the yeah like I said the expected types for these arguments and also the expected return type so right now when you look at this um it doesn't actually guarantee that this function can really handle these argument types it's just a type hint or it's just these three type hints and um you know I could just do this where I just force this function to return a string and uh it wouldn't really be an error right like matter of fact if I save this and then just run it through the um the python interpreter uh let's actually should probably call this um and call this function then the program still works even though it doesn't really follow this uh contract for for the types that we gave it now the way that types are going to be working in Python is that they're just type hints and then you need an external program almost like a linter that it's called a type Checker and you would need that type Checker program to actually look at your program code and then give you feedback on whether or not um your program code actually follows the the type annotations right so in this case uh this function would be violating its type annotations um and uh I'm going to show you now how you can actually run a type checker on this program so a really popular type Checker right now is mypie so let's install that for a second pip install my pie. Lang you want to make sure you install a pi mypie do mypie Dash Lang because just mypie without the dash Lang is something else entirely so you're not going to be happy with that cool so let's install my piie it's going to take a second here okay great and now what I'm going to do is just run my Pi on my types example.py cool and we actually got an error message here um which is great right because we we knew that our program was wasn't valid um in the sense that it was following the type annotations and so here my Pi tells us uh types example of Pi in function at this incompatible return value type got got stir expected int and this is pretty much exactly what we're saying here right and so we can fix that by changing it so it returns an INT right like we could either do something like that where we hardcode it and that would cause the type Checker to pass or we could we actually make it do something useful um like return the sum of these two and then that would still pass and you could see that you know having this uh a plus b is the return value is actually a little bit more complicated than just saying return 23 because it's kind of easy for for mypi to figure out that 23 is an integer constant but when you do actually when you actually do something like a plus b then mypi has to go and check the type off a and check the type off B and then actually figure out that if you add these two you end up with an integer as well so therefore the the typ pins um are accurate and we don't get uh a type error um so you can imagine that this technique can be scaled quite well and it actually already goes far beyond just that little experiment that I've showed you right because you know if you look at this like this wouldn't be really interesting it where it gets interesting is when you have thousands and hundreds of thousands of lines of code or millions of lines of code and you can use a tool like mypie to actually find find some um really big bugs that were previously undetected the tie hinting stuff is going to get more valuable as you have more and more code and as you you're able to kind of automatically find uh bugs that would be really hard to detect for a human in a in a ginormous code base right and kind of the make or break thing for this to work is having these typ hints already already there for let's say large parts of the Python standard library or third party libraries and so you know just to give you an example like let's say I import the random module and um I'm going to change my at this function to do something terrible which is um we're going to go and just make it return a random integer between A and B so now this still type checks cleanly which means that mypi actually understands that random Rand in returns an integer and and you know it it seems like really really straightforward for um a human because we have the the python docs and we kind of you know we're told this thing returns a random integer in range AB but um in a lot of cases like in some cases mypi might be able to infer that type and just figure it out on its own but in a lot of cases it's going to depend on people adding these type hins to functions in the um in the python standard library and also in uh other thirdparty libraries so like a big bulk of the work is is not just writing the type Checker which is you know difficult enough um it's a big project but also like a big bulk of the work is adding these type hints everywhere so that mypi and other other type checkers can be as effective as possible because if they if if a type Checker doesn't know what the the types are you're dealing with it doesn't really add a lot of value right it could still function as like a basic linter but it gets really interesting when you have all of these type checks so there's a big project right now it's I believe it's called the type shed project where people add these annotation to annotations to um the standard library to cover kind of as much of that as possible and then also people are starting to incorporate third party libraries like Jango and kind of the big popular ones and so well kind of how can I wrap this up right so because this was just meant to be as a as a small like intro video so I think I see a lot of power in in uh just having the possibility to to do CH type checking in Python because because like I said in the beginning it's going to enable a lot more use cases for python as a language which I think is awesome um and on the other hand and it's going to take a lot of work before this is really going to work seamlessly right because if you do this stuff like that in in a statically typed language like Java then um you're going to have to provide these types like from the get-go right so there never was a Java that didn't already have all of these types and that's why the compiler can work with it and can give you all this this helpful feedback but for python it's kind of the unique challenge is that the type checking stuff is going to be bolted on to Python and so now we're in this situation where you can already use this on a on a small scale like for small programs but it's going to take a little bit more time before actually all of the you know all of the other code is going to be covered well with typ hins so you can actually really use this on a larger code base without actually getting uh tons of warnings and errors that that aren't real errors that that just you know happen because the typ hints are missing or are ambiguous so all in all I think this is going to be a really interesting uh Direction python is going into and you know if you're interested in this stuff today or like now is probably a good time to get into it because then you're going to be at the Forefront of um this new language feature