With the release of Python 3.5, we were given a new feature called Type Hinting. Type hinting, also known as type annotation, is a way for us, the programmer to hint at the type of the object we are using. In this article, we will be exploring in detail, the benefits of Type hinting in Python, and how it can effectively be used.
What is Type Hinting?
Let’s take a quick look at what type hinting actually is, before talking about the benefits.
Python handles it’s type definitions in a rather different way from other languages like C++ and Java. Python uses dynamic typing, which doesn’t require variables to be declared with a type. This can become very confusing, very quickly, especially in larger applications or during the debugging process.
In response to this, Python introduced Type hinting, so we could inform the interpreter/IDE what type the variable was.
var: int = 5
The above code creates a variable called var, and initializes it to a value of 5. Now this informs the interpreter/IDE that this variable is an int. More on this later though, as what actually happens is a bit more complicated.
def add(one: int, two: int) -> int:
return (one + two)
Here is another short example, which features a function which only accepts two integers, and returns the sum of both integers.
How Type Hinting actually works
One quick misconception to clear up, before we discuss the pros and cons, is how type hinting actually works. To be clear, Type Hinting was not introduced to turn Python from a dynamically typed language to a static one. It’s use is meant to be limited to debugging and testing purposes for the programmer.
Like some might mistakenly believe, it does not make your variable statically declared, and will not throw an error if that type was violated.
var: int
var = "Hello"
If you run the following command on the default Python interpreter, this will run perfectly fine. Why though?
This is because type hinting merely “hints” or “suggests” to a type checker, what the type should be. Then it’s upto the type checker, to act accordingly. On the default Python interpreter, it will ignore any type hints, as it’s not configured to do so.
However, if you use a Static Type checker like mypy, or you use an IDE like PyCharm which automatically detects type hints, then an error will be raised upon executing such a statement.
Benefits of Type Hinting in Python
Let’s take a look at some of the various benefits and advantages of using Type hinting in Python.
Improved readability: Programmers might get confused when seeing a variable of a function parameter, not knowing what it’s type is. Type hinting helps to improve this aspect, and can make code more readable and understandable if used correctly.
Debugging: Type hints help us catch errors related to the type of variables much faster. Because of dynamic typing, you might not even realize that your variable is storing the wrong type of data, which might be causing problems later down the line. Type hinting helps you catch this kind of mistake early on.
Improve IDEs and linters. Type Hints work together with IDE’s, and help them provide better suggestions, more accurate auto-fills, and helps the IDE understand your code better. Overall it improves your programming experience in many little ways.
Documentation: Type hints are also a form of documentation. Normally in docs you need to specify the types of the variables and function parameters you used. Type hints help convey this fact, and reduce the overall documentation that you need to do.
Build and maintain cleaner architecture. The usage of type hinting forces you think more about the code you are writing, and overall produces code of a higher quality. Being constantly aware of what types you are dealing with, helps improve your code quality, and keeps you mentally aware of what exactly is being written, and for what purpose.
Disadvantages of Type Hinting
Time and Effort: Adding type hints to your code will increase the amount of time you spend coding. This is slightly offset however, by the time you might save during testing and debugging.
Compatibility with Python Versions. Type hinting was properly introduced in Python in 3.5, with some premature form being available from 3.0. However, type hinting wasn’t as great back then, as there were some issues. Type hinting was significantly improved in Python 3.6+. This also means that it’s not a good idea to use type hinting with older Python 3.x versions, and it cannot be used with Python 2.x.
Increase Startup Time: This may seem inconsequential to some, but to those who are writing performance based scripts and programs, this may matter. Importing the typing library adds a few milliseconds of extra startup time due to the time required to include it, and it’s functions.
When to use Type Hinting?
Now just because Type hinting in Python has alot of benefits, doesn’t mean you should be using it all the time. If not used correctly Type hinting will not yield any real benefits, and you will just be wasting your time unnecessarily.
Here are some basic guidelines to try and follow when using Type hinting.
- If you are a beginner to Python, you are better of not using type hints till you have gained some experience. Focus more on building logic, and making your code more readable naturally. You can come back to type hinting later.
- Avoid the use of type hinting in small scripts and programs. Don’t try and force it in unless you think it’s actually going to help.
- Using type hinting doesn’t you need to use it with every single variable and function parameter. Avoid using it on those variables and function parameters, whose use and type is obvious. In short, follow a hybrid system, and use type hinting only where required.
- As mentioned earlier, type hinting is great for documentation. If you are making a library, type hinting will serve as a helpful guide for those who may be using your library.
- Type hinting really shines in larger projects with multiple people, as it helps other people understand each other’s code. If you are working on such a project, then it’s best to enforce using Type hinting on everyone involved in the project.
This marks the end of the Benefits of Type Hinting in Python article. Any suggestions or contributions for CodersLegacy are more than welcome. Questions regarding the tutorial content can be asked in the comments section below.