Using Python 3's New Feature Type Annotations to Improve Code Readability

Look at the Code First

def add(x: int, y: int) -> int:
    return x + y

Those who haven't used type annotations (Type Annotations) might find it a bit confusing at first glance. In fact, the code above is the same as the following.

def add(x, y):
    return x + y

Introduction to Type Annotations

We know that Python is a dynamic language; variables and function parameters are not distinguished by type. The Python interpreter dynamically determines the types of variables and parameters at runtime. The advantage of this is that writing code is very fast and flexible, but the downside is also obvious: it's hard to maintain. After writing the code for a while, looking at it again can be difficult to understand, because the types of those variables, parameters, and function return values have all been forgotten. And when you're reading someone else's code, you also can't tell the types of variables or parameters at a glance; you often have to figure them out yourself, which creates a significant obstacle to learning.

So Python 3 has this new feature that lets you add annotations for the types of parameters, function return values, and variables. However, this is merely a comment and has no effect whatsoever on the running of the code. The actual types of variables are still determined by the Python interpreter. All you're doing is improving the readability of the code, nothing more.

Look at the Code

def add(x: int, y: int) -> int:
    return x + y


def area_calculation(radius: float) -> float:
    # 变量类型注解需要 py3.6 以上版本
    # Var Type Annotations need python 3.6 and later
    pi: float = 3.1415926
    return radius * radius * pi


if __name__ == '__main__':
    print(add(1, 2))
    print(add.__annotations__)
    print(area_calculation(2))
    print(area_calculation.__annotations__)

Run result:

3
{'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
12.5663704
{'radius': <class 'float'>, 'return': <class 'float'>}

Here we called the function's __annotations__ attribute, through which you can see the annotations for parameter and return value types.

Testing the Correctness of Annotations

As mentioned earlier, these annotations only serve as comments and do not affect code execution, so even if you write the type annotations incorrectly, the program will still run according to the correct types at runtime. Then, Python provides a tool that makes it convenient for us to test the correctness of type annotations in the code, mypy

First, install:

pip install mypy

To test:

mypy filename.py

If there are no errors, there is no output; if there are errors, there will be corresponding output, such as

$ mypy demo.py
demo.py:14: error: Incompatible return value type (got "float", expected "int")