众所周知，python是一种动态类型言语，可是，从v3.6版本开端，开端支撑静态类型的写法。

了解python的静态类型，有助于咱们封装愈加可靠和易于保护的工具和库。

动态和静态类型

动态和静态类型本来是区分言语种类的一个目标，
动态和静态言语各有优势和适用的场景，不能说那个必定比另一个好。

挑选静态类型或动态类型言语应依据详细的需求和状况进行权衡和评估。
在实践开发中，也能够依据项目的需求挑选不同的言语进行组合运用，以充分发挥各言语的优势。

动态言语好坏点

动态言语的优势主要有：

  1. 灵活性和简洁性：动态类型言语不要求显式声明变量的类型，能够依据上下文主动进行类型揣度，简化了代码的编写和了解。
  2. 更少的代码量：动态类型言语的代码通常比静态类型言语更简洁，减少了代码量和开发时刻。
  3. 更少的类型转化：因为动态类型言语在运转时进行类型查看和类型转化，能够主动进行一些类型转化，减少了开发者手动转化类型的工作。

动态言语的下风主要有：

  1. 简略出现隐式类型转化过错：因为动态类型言语在运转时进行类型转化，可能会出现一些隐式的类型转化过错，增加了调试的难度和本钱。
  2. 可读性和可保护性较差：动态类型言语中，变量的类型信息不够清晰，代码可读性和可保护性较差，增加了代码了解和保护的难度。

静态言语的好坏点

静态类型言语的优势主要有：

  1. 更严厉的类型查看：静态类型言语要求变量在运用之前有必要声明其类型，并在编译时进行类型查看，能够避免一些常见的类型过错，提高代码的可靠性。
  2. 更早的过错检测：因为静态类型言语在编译时进行类型查看，能够在代码运转之前捕获一些潜在的过错，减少调试时刻和本钱。
  3. 更好的可读性和可保护性：静态类型言语中，变量的类型信息愈加清晰，代码更易于了解和保护，减少了开发者之间的交流本钱。

静态类型言语的下风主要有：

  1. 代码量较大：因为需求显式声明变量的类型，静态类型言语的代码量通常较大，增加了代码的复杂度和开发时刻。
  2. 程序员需求更多的类型常识：运用静态类型言语需求对类型系统有必定的了解，并且需求花费更多的时刻来处理类型转化和类型查看。

python静态类型

依据经历，一般偏底层或算法的应用会用静态语音来编写，偏应用层或者脚本的应用会用动态言语来编写。

如今，python能够支撑静态类型的方法来编写代码，必然能够让它的应用规模进一步扩展。

静态类型语法

变量定义：

variable_name: type

复合类型：

from typing import Dict, List, Tuple

函数定义：

def function_name(param: type)-> return_type:

静态类型示例

一般变量示例：

i: int = 1
s: str= "abc"
print(i, s)
#运转成果：
1 abc

复合类型示例：

from typing import Dict, List, Tuple
numbers: List[int] = [1, 2, 3, 4, 5, 100]
numbers_dict: Dict[str, int] = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
    "five": 5,
    "hundred": 100,
}
multi_type_tuple: Tuple[str, int, bool] = ("one", 1, False)
print(numbers)
print(numbers_dict)
print(multi_type_tuple)
#运转成果：
[1, 2, 3, 4, 5, 100]
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'hundred': 100}
('one', 1, False)

函数示例：

def sum(a: int, b: int) -> int:
    return a + b
print(sum(10, 20))
#运转成果：
30

静态类型查看

python本质上毕竟仍是动态言语，尽管支撑按照静态类型的语法写代码，
可是代码履行时仍是以动态类型的方法去运转的。

比如下面的示例（test.py）：

def sum(a: int, b: int) -> int:
    return a + b
print(sum(10, 20))
print(sum("10", "20")) # 你的IDE也许会提示类型过错， 可是依然能够履行
#运转成果：
30
1020

上面的代码也许会提示类型过错（依据你的IDE装备状况来看），
可是履行仍是能够履行，这样，咱们静态类型的写法就没有意义了。

咱们的本意是期望像静态类型言语相同，在实践履行前查看类型是否合法。
这时，咱们能够运用mypy 工具来查看咱们代码中的类型状况。

pip install mypy

简略封装一个查看类型的脚本(check_run.py）：

import subprocess
import sys
def type_check(script):
    output = subprocess.run(['mypy', script], stdout=subprocess.PIPE).stdout
    return output.decode('utf-8')
def run(script):
    output = subprocess.run(['python3.6', script])
if __name__ == '__main__':
    script = sys.argv[1]
    mypy_output = type_check(script)
    if mypy_output != '':
        print(mypy_output)
    else:
        run(script)

用上面的 test.py 作为测试脚本，默许履行：

$ python ./test.py
30
1020

加上查看类型的功用，mypy会帮助咱们查看出来代码中的类型问题：

$ python check_run.py test.py
test.py:9: error: Argument 1 to "sum" has incompatible type "str"; expected "int"  [arg-type]
test.py:9: error: Argument 2 to "sum" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

总结

python中加入静态类型，让咱们写代码时多了一个挑选，并不是必定要用这种静态类型的写法。
咱们之前运用python的方法依然有用的。

我想，主要原因仍是在于python中现已应用在很多谨慎的数值核算方面，
特别是在人工智能兴起之后，python也随之大放异彩，逐步渗透到一些底层的场景中。

这时，对python的稳定性和可保护性的要求远远大于其易用性了，所以，才会开端支撑这种静态类型言语的写法。