初识Python模块typing、mypy类型注释

It’s usually faster to write new code in a dynamically-typed language like Python because you don’t have to write out all the type declarations by hand. But when your codebase starts to get large, you’ll inevitably run into lots of runtime bugs that static typing would have prevented.

It’s not all-or-nothing. So you can start by declaring types in the places that are the most valuable without changing all your code.

1. Subtype relationships

   A crucial notion for static type checker is the subtype relationship.

   It arises from the question: if first_var has type first_type, and second_var has type second_type, is it safe to assign first_var = second_var?

2. type vs. class

   In Python, classes are object factories defined by the class statement, and returned by the type(obj) built-in function. Class is a dynamic, runtime concept.

   types appear in variable and function type annotations, can be constructed from building blocks described below, and are used by static type checkers.

3. fundamental building blocks

   • Any
   • Union[t1, t2, …]
   • Optional[t1]
   • Tuple[t1, t2, …, tn]
   • Callable[[t1, t2, …, tn], tr] 函数，变量为t1,t2,…，返回值为tn
   • Intersection[t1, t2, …]

4. Generic types

   The fundamental building blocks defined above allow to construct new types in a generic manner.

The most fundamental support consists of the types Any, Union, Tuple, Callable, TypeVar and Generic.

variable: type
my_string: str = "My String Value"
def greeting(name: str) -> str:return "Hello" + name

Mypy is an optional static type checker for Python that aims to combine the benefits of dynamic(or “duck”) typing and static typing.

Mypy combines the expressive power and convenience of Python with a powerful type system and compile-time type checking.

Mypy type checks standard Python programs, run them using any Python VM with basically no runtime overhead.

Migrate existing code to static typing, a function at a time. you can freely mix static and dynamic typing within a program, within a module or within an expression. No need to give up dynamic typing – use static typing when it makes sense. Often just adding function signatures gives you statically typed code.

Through mypy program.py , it will check for errors without ever running your code, just like a linter.

You can find many of more complex static types inside of the typing module.