Python中typing模块与类型注解的使⽤⽅法
实例引⼊
我们知道 Python 是⼀种动态语⾔，在声明⼀个变量时我们不需要显式地声明它的类型，例如下⾯的例⼦：
a = 2
print('1 + a =', 1 + a)
运⾏结果：
1 + a = 3
这⾥我们⾸先声明了⼀个变量 a，并将其赋值为了 2，然后将最后的结果打印出来，程序输出来了正确的结果。但在这个过程中，我们没有声明它到底是什么类型。
但如果这时候我们将 a 变成⼀个字符串类型，结果会是怎样的呢？改写如下：
a = '2'
print('1 + a =', 1 + a)
运⾏结果：
TypeError: unsupported operand type(s) for +: 'int' and 'str'
直接报错了，错误原因是我们进⾏了字符串类型的变量和数值类型变量的加和，两种数据类型不同，是⽆法进⾏相加的。
如果我们将上⾯的语句改写成⼀个⽅法定义：
def add(a):
return a + 1
这⾥定义了⼀个⽅法，传⼊⼀个参数，然后将其加 1 并返回。
如果这时候如果⽤下⾯的⽅式调⽤，传⼊的参数是⼀个数值类型：
add(2)
则可以正常输出结果 3。但如果我们传⼊的参数并不是我们期望的类型，⽐如传⼊⼀个字符类型，那么就会同样报刚才类似的错误。
但⼜由于 Python 的特性，很多情况下我们并不⽤去声明它的类型，因此从⽅法定义上⾯来看，我们实际上是不知道⼀个⽅法的参数到底应该传⼊什么类型的。
这样其实就造成了很多不⽅便的地⽅，在某些情况下⼀些复杂的⽅法，如果不借助于⼀些额外的说明，我们是不知道参数到底是什么类型的。
因此，Python 中的类型注解就显得⽐较重要了。
类型注解
在 Python 3.5 中，Python PEP 484 引⼊了类型注解（type hints），在 Python 3.6 中，PEP 526 ⼜进⼀步引⼊了变量注解（Variable Annotations），所以上⾯的代码我们改写成如下写法：
a: int = 2
print('5 + a =', 5 + a)
def add(a: int) -> int:
return a + 1
具体的语法是可以归纳为两点：
在声明变量时，变量的后⾯可以加⼀个冒号，后⾯再写上变量的类型，如 int、list 等等。
在声明⽅法返回值的时候，可以在⽅法的后⾯加⼀个箭头，后⾯加上返回值的类型，如 int、list 等等。
在中，具体的格式是这样规定的：
在声明变量类型时，变量后⽅紧跟⼀个冒号，冒号后⾯跟⼀个空格，再跟上变量的类型。
在声明⽅法返回值的时候，箭头左边是⽅法定义，箭头右边是返回值的类型，箭头左右两边都要留有空格。
有了这样的声明，以后我们如果看到这个⽅法的定义，我们就知道传⼊的参数类型了，如调⽤ add ⽅法的时候，我们就知道传⼊的需要是⼀个数值类型的变量，⽽不是字符串类型，⾮常直观。
但值得注意的是，这种类型和变量注解实际上只是⼀种类型提⽰，对运⾏实际上是没有影响的，⽐如调⽤ add ⽅法的时候，我们传⼊的不是 int 类型，⽽是⼀个 float 类型，它也不会报错，也不会对参数进⾏类型转换，如：
add(1.5)
我们传⼊的是⼀个 float 类型的数值 1.5，看下运⾏结果：
2.5
可以看到，运⾏结果正常输出，⽽且 1.5 并没有经过强制类型转换变成 1，否则结果会变成 2。
因此，类型和变量注解只是提供了⼀种提⽰，对于运⾏实际上没有任何影响。
不过有了类型注解，⼀些 IDE 是可以识别出来并提⽰的，⽐如 PyCharm 就可以识别出来在调⽤某个⽅法的时候参数类型不⼀致，会提⽰ WARNING。
⽐如上⾯的调⽤，如果在 PyCharm 中，就会有如下提⽰内容：
Expected type 'int', got 'float' instead
This inspection detects type errors in function call expressions. Due to dynamic dispatch and duck typing, this is
possible in a limited but useful number of cases. Types of function parameters can be specified in docs
trings or in Python 3 function annotations.
另外也有⼀些库是⽀持类型检查的，⽐如 mypy，安装之后，利⽤ mypy 即可检查出 Python 脚本中不符合类型注解的调⽤情况。
上⾯只是⽤⼀个简单的 int 类型做了实例，下⾯我们再看下⼀些相对复杂的数据结构，例如列表、元组、字典等类型怎么样来声明。
可想⽽知了，列表⽤ list 表⽰，元组⽤ tuple 表⽰，字典⽤ dict 来表⽰，那么很⾃然地，在声明的时候我们就很⾃然地写成这样了：
names: list = ['Germey', 'Guido']
version: tuple = (3, 7, 4)
operations: dict = {'show': False, 'sort': True}
这么看上去没有问题，确实声明为了对应的类型，但实际上并不能反映整个列表、元组的结构，⽐如我们只通过类型注解是不知道 names ⾥⾯的元素是什么类型的，只知道 names 是⼀个列表 list 类型，实际上⾥⾯都是字符串 str 类型。我们也不知道version 这个元组的每⼀个元素是什么类型的，实际上是 in
t 类型。但这些信息我们都⽆从得知。因此说，仅仅凭借 list、tuple 这样的声明是⾮常“弱”的，我们需要⼀种更强的类型声明。
这时候我们就需要借助于 typing 模块了，它提供了⾮常“强“的类型⽀持，⽐如 List[str]、Tuple[int, int, int] 则可以表⽰由 str 类型的元素组成的列表和由 int 类型的元素组成的长度为 3 的元组。所以上⽂的声明写法可以改写成下⾯的样⼦：
from typing import List, Tuple, Dict
names: List[str] = ['Germey', 'Guido']
version: Tuple[int, int, int] = (3, 7, 4)
operations: Dict[str, bool] = {'show': False, 'sort': True}
这样⼀来，变量的类型便可以⾮常直观地体现出来了。
⽬前 typing 模块也已经被加⼊到 Python 标准库中，不需要安装第三⽅模块，我们就可以直接使⽤了。
typing
下⾯我们再来详细看下 typing 模块的具体⽤法，这⾥主要会介绍⼀些常⽤的注解类型，如 List、Tuple、Dict、Sequence 等等，了解了每个类型的具体使⽤⽅法，我们可以得⼼应⼿的对任何变量进⾏声明了。
在引⼊的时候就直接通过 typing 模块引⼊就好了，例如：
from typing import List, Tuple
List
List、列表，是 list 的泛型，基本等同于 list，其后紧跟⼀个⽅括号，⾥⾯代表了构成这个列表的元素类型，如由数字构成的列
表可以声明为：
var: List[int or float] = [2, 3.5]
另外还可以嵌套声明都是可以的：
var: List[List[int]] = [[1, 2], [2, 3]]
Tuple、NamedTuple
Tuple、元组，是 tuple 的泛型，其后紧跟⼀个⽅括号，⽅括号中按照顺序声明了构成本元组的元素类型，如 Tuple[X, Y] 代表了构成元组的第⼀个元素是 X 类型，第⼆个元素是 Y 类型。
⽐如想声明⼀个元组，分别代表姓名、年龄、⾝⾼，三个数据类型分别为 str、int、float，那么可以这么声明：
person: Tuple[str, int, float] = ('Mike', 22, 1.75)
同样地也可以使⽤类型嵌套。
NamedTuple，是 collections.namedtuple 的泛型，实际上就和 namedtuple ⽤法完全⼀致，但个⼈其实并不推荐使⽤NamedTuple，推荐使⽤ attrs 这个库来声明⼀些具有表征意义的类。
Dict、Mapping、MutableMapping
Dict、字典，是 dict 的泛型；Mapping，映射，是 collections.abc.Mapping 的泛型。根据官⽅⽂档，Dict 推荐⽤于注解返回类型，Mapping 推荐⽤于注解参数。它们的使⽤⽅法都是⼀样的，其后跟⼀个中括号，中括号内分别声明键名、键值的类型，如：
def size(rect: Mapping[str, int]) -> Dict[str, int]:
return {'width': rect['width'] + 100, 'height': rect['width'] + 100}
这⾥将 Dict ⽤作了返回值类型注解，将 Mapping ⽤作了参数类型注解。
MutableMapping 则是 Mapping 对象的⼦类，在很多库中也经常⽤ MutableMapping 来代替 Mapping。
Set、AbstractSet
Set、集合，是 set 的泛型；AbstractSet、是 collections.abc.Set 的泛型。根据官⽅⽂档，Set 推荐⽤于注解返回类
型，AbstractSet ⽤于注解参数。它们的使⽤⽅法都是⼀样的，其后跟⼀个中括号，⾥⾯声明集合中元素的类型，如：
def describe(s: AbstractSet[int]) -> Set[int]:
return set(s)
这⾥将 Set ⽤作了返回值类型注解，将 AbstractSet ⽤作了参数类型注解。
Sequence
Sequence，是 collections.abc.Sequence 的泛型，在某些情况下，我们可能并不需要严格区分⼀个变量或参数到底是列表 list 类型还是元组 tuple 类型，我们可以使⽤⼀个更为泛化的类型，叫做 Sequence，其⽤法类似于 List，如：
def square(elements: Sequence[float]) -> List[float]:
return [x ** 2 for x in elements]
NoReturn
NoReturn，当⼀个⽅法没有返回结果时，为了注解它的返回类型，我们可以将其注解为 NoReturn，例如：
def hello() -> NoReturn:
print('hello')
Any
Any，是⼀种特殊的类型，它可以代表所有类型，静态类型检查器的所有类型都与 Any 类型兼容，所有的⽆参数类型注解和返回类型注解的都会默认使⽤ Any 类型，也就是说，下⾯两个⽅法的声明是完全等价的：
def add(a):
return a + 1
def add(a: Any) -> Any:
return a + 1
TypeVar
TypeVar，我们可以借助它来⾃定义兼容特定类型的变量，⽐如有的变量声明为 int、float、None 都是符合要求的，实际就是代表任意的数字或者空内容都可以，其他的类型则不可以，⽐如列表 list、字典 dict 等等，像这样的情况，我们可以使⽤TypeVar 来表⽰。
例如⼀个⼈的⾝⾼，便可以使⽤ int 或 float 或 None 来表⽰，但不能⽤ dict 来表⽰，所以可以这么声明：
height = 1.75
Height = TypeVar('Height', int, float, None)
def get_height() -> Height:
return height
这⾥我们使⽤ TypeVar 声明了⼀个 Height 类型，然后将其⽤于注解⽅法的返回结果。
NewType
NewType，我们可以借助于它来声明⼀些具有特殊含义的类型，例如像 Tuple 的例⼦⼀样，我们需要将它表⽰为 Person，即⼀个⼈的含义，但但从表⾯上声明为 Tuple 并不直观，所以我们可以使⽤ NewType 为其声明⼀个类型，如：
Person = NewType('Person', Tuple[str, int, float])
person = Person(('Mike', 22, 1.75))
这⾥实际上 person 就是⼀个 tuple 类型，我们可以对其像 tuple ⼀样正常操作。
Callable
Callable，可调⽤类型，它通常⽤来注解⼀个⽅法，⽐如我们刚才声明了⼀个 add ⽅法，它就是⼀个 Callable 类型：
print(Callable, type(add), isinstance(add, Callable))
运⾏结果：
typing.Callable <class 'function'> True
在这⾥虽然⼆者 add 利⽤ type ⽅法得到的结果是 function，但实际上利⽤ isinstance ⽅法判断确实是 True。
Callable 在声明的时候需要使⽤ Callable[[Arg1Type, Arg2Type, ...], ReturnType] 这样的类型注解，将参数类型和返回值类型都要注解出来，例如：
def date(year: int, month: int, day: int) -> str:
return f'{year}-{month}-{day}'
def get_date_fn() -> Callable[[int, int, int], str]:
return date
这⾥⾸先声明了⼀个⽅法 date，接收三个 int 参数，返回⼀个 str 结果，get_date_fn ⽅法返回了这个⽅法本⾝，它的返回值类型就可以标记为 Callable，中括号内分别标记了返回的⽅法的参数类型和返回值类型。
Union
Union，联合类型，Union[X, Y] 代表要么是 X 类型，要么是 Y 类型。
联合类型的联合类型等价于展平后的类型：
Union[Union[int, str], float] == Union[int, str, float]
仅有⼀个参数的联合类型会坍缩成参数⾃⾝，⽐如：
Union[int] == int
多余的参数会被跳过，⽐如：
Union[int, str, int] == Union[int, str]
在⽐较联合类型的时候，参数顺序会被忽略，⽐如：
Union[int, str] == Union[str, int]
这个在⼀些⽅法参数声明的时候⽐较有⽤，⽐如⼀个⽅法，要么传⼀个字符串表⽰的⽅法名，要么直接把⽅法传过来：
def process(fn: Union[str, Callable]):
if isinstance(fn, str):
# str2fn and process
pass
elif isinstance(fn, Callable):
fn()
这样的声明在⼀些类库⽅法定义的时候⼗分常见。
Optional
Optional，意思是说这个参数可以为空或已经声明的类型，即 Optional[X] 等价于 Union[X, None]。
但值得注意的是，这个并不等价于可选参数，当它作为参数类型注解的时候，不代表这个参数可以不传递了，⽽是说这个参数可以传为 None。
如当⼀个⽅法执⾏结果，如果执⾏完毕就不返回错误信息，如果发⽣问题就返回错误信息，则可以这么声明：
def judge(result: bool) -> Optional[str]:
if result: return 'Error Occurred'
Generator
如果想代表⼀个⽣成器类型，可以使⽤ Generator，它的声明⽐较特殊，其后的中括号紧跟着三个参数，分别代表YieldType、SendType、ReturnType，如：
def echo_round() -> Generator[int, float, str]:
sent = yield 0
while sent >= 0:
sent = yield round(sent)
return 'Done'
在这⾥ yield 关键字后⾯紧跟的变量的类型就是 YieldType，yield 返回的结果的类型就是 SendType，最后⽣成器 return 的内容就是 ReturnType。
当然很多情况下，⽣成器往往只需要 yield 内容就够了，我们是不需要 SendType 和 ReturnType 的，可以将其设置为空，如：
def infinite_stream(start: int) -> Generator[int, None, None]:
while True:
yield start
start += 1
案例实战
接下来让我们看⼀个实际的项⽬，看看经常⽤到的类型⼀般是怎么使⽤的。
⾸先 Typing 的定义部分如下：
from typing import Set, Union, List, MutableMapping, Optional
_Find = Union[List['Element'], 'Element']
_XPath = Union[List[str], List['Element'], str, 'Element']
_Result = Union[List['Result'], 'Result']
_HTML = Union[str, bytes]
_BaseHTML = str
_UserAgent = str
_DefaultEncoding = str
_URL = str
_RawHTML = bytes
pycharm安装教程和使用_Encoding = str
_LXML = HtmlElement
_Text = str
_Search = Result
_Containing = Union[str, List[str]]
_Links = Set[str]
_Attrs = MutableMapping
_Next = Union['HTML', List[str]]
_NextSymbol = List[str]
这⾥可以看到主要⽤到的类型有 Set、Union、List、MutableMapping、Optional，这些在上⽂都已经做了解释，另外这⾥使⽤了多次 Union 来声明了⼀些新的类型，如 _Find 则要么是是 Element 对象的列表，要么是单个 Element 对象，_Result 则要么是 Result 对象的列表，要么是单个 Result 对象。另外 _Attrs 其实就是字典类型，这⾥⽤ MutableMapping 来表⽰了，没有⽤ Dict，也没有⽤ Mapping。
接下来再看⼀个 Element 类的声明：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。