# Python 3.5 类型注解 : - ＞屠龙者终成恶龙？

本文链接：https://blog.csdn.net/crazyjinks/article/details/141257459

Python 3.5 类型注解: - > 屠龙者终成恶龙？

引言：动态类型的双刃剑

Python 作为一门动态类型语言,长期以来以其灵活性和简洁性而受到半路出家的开发者们的喜爱。相较于不以臃肿为耻，反以繁复为荣的Java 等静态类型语言来说，python的print(”Hello!“)直出，显得就特别优雅，优雅到一些狂热的python信徒甚至提出了the Zen of Python，大有python邪教，一统江湖，千秋万代的意味。不过成也萧何,败也萧何。

我们可以看看隔壁JavaScript 的发展历程。作为一门动态类型语言,JavaScript 在 Web 开发领域一度占据主导地位。然而,随着项目规模的增大和复杂度的提高,开发者们逐渐意识到,缺乏类型信息会导致代码难以理解、难以重构,并且容易引入难以发现的 bug。这就是为什么 TypeScript 应运而生,并迅速成为前端开发的新宠。TypeScript 在保留 JavaScript 灵活性的同时,引入了可选的静态类型,大大提高了代码的可维护性和可靠性。

Python 社区也面临着类似的挑战。虽然 Python 的动态特性使其成为许多领域的首选语言,但在大型项目中,类型相关的问题也日益凸显。让我们看一个具体的例子:

假设我们正在开发一个简单的计算器应用,其中有一个函数用于计算两个数的和。

def add(a, b):
    return a + b

乍一看,这个函数非常简单明了吧。优雅到骨子里了，我们期望它能够接受两个数字,并返回它们的和。但是,由于 Python 是一门动态类型语言,这个函数实际上可以接受任何类型的参数。例如:

print(add(1, 2))  # 输出: 3
print(add('Hello, ', 'world!'))  # 输出: 'Hello, world!'
print(add([1, 2], [3, 4]))  # 输出: [1, 2, 3, 4]

在第一个例子中,add 函数表现出了我们预期的行为:对于数字,它返回它们的和;
在第二个例子中，调用这个函数的另一个开发者SuperClever觉得对于字符串,这个函数可以拼在一起，于是他选择把它们拼接在一起。
在第三个例子中,开发者EX-Smart 想对两个列表进行元素级的加法(即矩阵加法),期望得到 [4, 6], 不过Python 解释器默认执行了列表拼接操作函数的行为，它将两个列表合并成了一个新列表, EX-Smart 扣起了脑袋。

这种行为的不一致性可能会导致难以发现的 bug。因为项目规模扩大后，一万个开发者，有一万部哈姆雷特,这里只是错误地将两个列表传递给了 add 函数, 在更复杂的项目中，我们写的 bug 可能会潜伏更长时间,直到某个大聪明输入触发了它,才会被发现。

类型注解的崛起：屠龙者终成魔龙？

正如前面引言所介绍的随着 Python 在大型项目和企业级应用中的广泛使用,代码的可维护性、可读性和健壮性逐渐成为开发者们不得不面对的问题。屠龙者终成魔龙，Python 社区开始意识到,为了应对这些挑战,需要引入一些原本被视为"不必要"的特性 —— 类型注解就是其中之一。

Python 3.5：类型注解的里程碑

历史背景

Python 的类型注解并非凭空而来。早在 Python 2.7 时代,就有通过注释来提供类型信息的尝试(如 PyCharm 使用的类型注释)。然而,这种方法并不标准,也缺乏语言级别的支持。

Python 3.5 的发布标志着类型注解正式成为语言特性。这一决定源于 Python 社区对以下需求的认识:

提高大型项目的可维护性
增强代码的自文档化能力
支持更强大的第三方静态分析工具
在保持 Python 动态特性的同时,为开发者提供类型安全的选项

PEP 484: 类型注解的标准化

在这里插入图片描述

于是在PEP 484，Python 类型注解的标准化提案,它引入了一套标准的类型注解语法和语义。这个提案的主要目标包括:

为静态类型分析提供标准词汇表和工具
定义类型注解的语法和语义,以确保不同工具之间的一致性
为没有注解的情况提供约定
支持渐进式的类型引入,而不影响现有代码

PEP 484 强调,类型注解是可选的,并不妨碍 Python 的其他用途。它也不要求对符合规范的注解进行任何特定处理。目的是为了更好地协调不同的静态类型检查工具。

核心特性：冒号(:)和箭头(->)

Python 3.5 引入了两种主要的类型注解语法:

变量注解( : )
```
variable: type
```
返回值注解( -> )
```
def function() -> return_type:
    ...
```

这两种语法允许开发者明确指定变量类型和函数返回类型,而不影响 Python 的运行时行为。

实际应用示例

def calculate_area(radius: float) -> float:
    return 3.14 * radius ** 2

class User:
    name: str
    age: int

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def is_adult(self) -> bool:
        return self.age >= 18

在这个例子中,我们定义了一个计算圆面积的函数 calculate_area,以及一个表示用户的类 User。通过类型注解,我们清晰地表明了每个函数的参数类型和返回值类型,以及类的属性类型。

对于 calculate_area 函数,我们指定它接受一个 float 类型的参数 radius,并返回一个 float 类型的值。这样,当其他开发者使用这个函数时,他们就能够一目了然地知道应该传入什么样的参数,以及可以期望得到什么样的返回值。

对于 User 类,我们在类的属性 name 和 age 上添加了类型注解,明确指定 name 是 str 类型,age 是 int类型。同时,我们也为构造函数 init 和方法 is_adult 添加了类型注解。这样,当其他开发者使用这个类时,他们就能够清楚地知道每个属性和方法的类型,避免了许多潜在的类型相关的错误。

深入理解：Union 和复杂类型

类型注解系统的强大之处不仅在于基本类型,还在于它能够表达复杂的类型关系。typing 模块提供了许多高级类型构造器,其中 Union 是最常用的之一。

Union：多类型可能性的表达

Union 允许我们指定一个值可能是几种类型中的一种:

from typing import Union

def process_input(data: Union[str, int]) -> Union[str, None]:
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, int):
        return str(data)
    return None

这个例子展示了如何使用 Union 来处理多种可能的输入和输出类型。

抽象基类的泛型支持

在Python中，我们有一些容器类型，比如列表(List)、集合(Set)、字典(Dict)等。当我们使用类型注解时，仅仅知道某个变量是一个列表或字典是不够的。我们通常还想知道这个容器里面包含的是什么类型的元素。
Python的类型系统引入了一种方式，允许我们使用下标符号来指定容器内元素的类型由于容器中对象的类型信息无法以通用方式进行静态推断,抽象基类已经扩展为支持通过下标来表示容器元素的预期类型。例如:

from typing import Mapping, Set

def notify_by_email(employees: Set[Employee], overrides: Mapping[str, str]) -> None:
    ...

在这个例子中：

Set[Employee] 表示 employees 是一个集合，其中的每个元素都是 Employee类型。
Mapping[str, str] 表示 overrides 是一个映射（比如字典），其中键和值都是字符串类型。

使用 TypeVar 进行泛型参数化

泛型可以通过在 typing 模块中使用名为 TypeVar 的工厂函数来进行参数化。例如:

from typing import Sequence, TypeVar

T = TypeVar('T')      # 声明类型变量

def first(l: Sequence[T]) -> T:   # 泛型函数
    return l[0]

在这个例子中,我们声明了一个类型变量 T,然后在函数 first 的签名中使用它来表示序列元素的类型和返回值的类型。这使得 first 函数可以适用于任何类型的序列,同时确保返回值与序列元素的类型相同。

其他复杂类型

除了 Union,typing 模块还提供了许多其他有用的类型:

List, Dict, Tuple: 用于容器类型
Optional: 表示可能为 None 的值
Callable: 用于函数和可调用对象
Any: 表示任意类型

from typing import List, Dict, Optional, Callable

def process_data(items: List[Dict[str, Any]],
                 callback: Optional[Callable[[str], None]] = None) -> None:
    for item in items:
        if callback:
            callback(str(item))

类型注解的影响和优势

提高代码可读性：明确的类型信息使代码意图更加清晰。
增强 IDE 支持：更准确的代码补全和错误检测。
静态类型检查：使用工具如 mypy 进行早期错误检测。
改善文档：类型注解本身就是一种活的文档。
辅助重构：在大型代码库中进行更改时,类型信息能够提供重要指导。

其他问题：

"静态推断"是什么意思？

这指的是在不运行代码的情况下，仅通过分析代码来确定类型。对于容器类型，如果不使用这种下标表示法，静态分析工具很难知道容器内部元素的具体类型。

"抽象基类"指的是什么？

在Python的collections.abc模块中定义了一些抽象基类，如Sequence、Mapping等。这些类被扩展以支持这种下标表示法

Python 3.10+：语法糖的进化

从 Python 3.10 开始,类型注解语法得到了进一步简化。特别是对于 Union 类型,现在可以使用 | 操作符:

# Python 3.10+ syntax
def fetch_data() -> int | str | None:
    ...

# Equivalent to:
from typing import Union
def fetch_data() -> Union[int, str, None]:
    ...

结语：平衡与前瞻

Python 的类型注解体系代表了语言设计中寻求平衡的一个案例。它在保持 Python 动态特性和简洁语法的同时,为那些需要更严格类型控制的场景提供了解决方案。随着 Python 在各个领域的深入应用,类型注解无疑将在提升代码质量、支持大型项目开发方面发挥越来越重要的作用。我们可以看到现在开源项目基本上都使用了类型注解，我们自己做开发的时候，也应该遵循这种规范，当然，类型注解始终是可选的。Python 依然是,也将继续是一门动态类型语言。类型注解的引入不是要改变 Python 的本质,而是要为开发者提供更多的工具和选择,以应对不同规模和复杂度的项目需求。

所以，从成为一个更好的开发者而言，应当引入并习惯类型注解，但是从防御性编程，使用更多语法糖，让自己代码变得不可读和混乱，那就，见仁见智了，have fun~ 我的朋友。