Boost Your Python Code Quality with Type Annotations

Preface

Hi everyone, today we discuss a fun Python future trend and a practical solution for collaborative development.

Although Python is highly productive and flexible, its dynamic nature often leads to inconsistent code styles when multiple developers work together.

To mitigate this, Python 3.6 introduced type annotations, allowing developers to declare expected variable and function parameter types.

Environment

Python interpreter 3.6+

Using Python 3.6 or newer is recommended because asynchronous features are emerging and will further enhance Python's capabilities.

A Simple Example

def speak(name, age):
    print(name, age)

speak("张三", "18")

In this example, the name parameter is intended to be a string, but without annotations the interpreter cannot enforce it.

If we want name to always be uppercase, we can use the string upper() method. print("stark".upper()) When typing a dot after a variable, IDEs may not always provide autocomplete hints because Python determines types at runtime.

Adding a type annotation makes the intention explicit:

def speak(name: str, age: int):
    print(name, age)

If a non‑string value is passed, editors like PyCharm or VS Code will show a warning such as “Expected type 'str' but got 'int'”.

Declare Simple Types

Common simple types include int, float, str, bool, etc. Whether for function parameters or variable declarations, the syntax is variable: type.

More Types

Lists

Dicts

Classes

Functions

Conclusion

The examples above cover basic type annotations that are sufficient for most everyday coding tasks.

While some may argue that adding annotations feels like extra work compared to dynamic typing, the benefits for code readability, maintenance, and collaboration are significant, especially as more libraries and projects adopt static typing.

Type annotations help both the original author and future readers understand the intended data structures, making them a valuable skill to learn.