详解Python中静态类型语言的写法

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

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

动态和静态类型

动态和静态类型本来是区分语言种类的一个指标，

动态和静态语言各有优势和适用的场景，不能说那个一定比另一个好。

选择静态类型或动态类型语言应根据具体的需求和情况进行权衡和评估。

在实际开发中，也可以根据项目的需要选择不同的语言进行组合使用，以充分发挥各语言的优势。

动态语言优劣点

动态语言的优势主要有：

• 灵活性和简洁性：动态类型语言不要求显式声明变量的类型，可以根据上下文自动进行类型推断，简化了代码的编写和理解。
• 更少的代码量：动态类型语言的代码通常比静态类型语言更简洁，减少了代码量和开发时间。
• 更少的类型转换：由于动态类型语言在运行时进行类型检查和类型转换，可以自动进行一些类型转换，减少了开发者手动转换类型的工作。

动态语言的劣势主要有：

• 容易出现隐式类型转换错误：由于动态类型语言在运行时进行类型转换，可能会出现一些隐式的类型转换错误，增加了调试的难度和成本。
• 可读性和可维护性较差：动态类型语言中，变量的类型信息不够明确，代码可读性和可维护性较差，增加了代码理解和维护的难度。

静态语言的优劣点

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

• 更严格的类型检查：静态类型语言要求变量在使用之前必须声明其类型，并在编译时进行类型检查，可以避免一些常见的类型错误，提高代码的可靠性。
• 更早的错误检测：由于静态类型语言在编译时进行类型检查，可以在代码运行之前捕获一些潜在的错误，减少调试时间和成本。
• 更好的可读性和可维护性：静态类型语言中，变量的类型信息更加明确，代码更易于理解和维护，减少了开发者之间的沟通成本。

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

• 代码量较大：由于需要显式声明变量的类型，静态类型语言的代码量通常较大，增加了代码的复杂度和开发时间。
• 程序员需要更多的类型知识：使用静态类型语言需要对类型系统有一定的了解，并且需要花费更多的时间来处理类型转换和类型检查。

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的稳定性和可维护性的要求远远大于其易用性了，所以，才会开始支持这种静态类型语言的写法。

到此这篇关于详解Python中静态类型语言的写法的文章就介绍到这了,更多相关Python静态类型语言内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论