python类型注解 知乎（Python 类型注解）

在Python语言发展的过程中
    
    
    
    
，PEP提案发挥了巨大的作用     


     


     


     


   ，如PEP 3107 和 PEP 484提案 




 




 




 




 

，分别给我们带来了函数注解（Function Annotations）和类型提示（Type Hints）的功能
    
    
    
    
。

PEP 3107：定义了函数注解的语法

   

   

   

   

，允许为函数的参数和返回值添加元数据注解     


     


     


     


   。

PEP 484：按照PEP 3107函数注解的语法     

     

     

     

  ，从Python语法层面全面支持类型提示  




  




  




  




  
，类型提示可以是内置类型
    
    
    
    
、内置类     


     


     


     


   、抽象基类 




 




 




 




 

、types模块中提供的类型和开发人员自定义的类 




 




 




 




 

。

另外 PEP 526, PEP 544, PEP 586, PEP 589, PEP 591 这些东西对 PEP 3107 和 PEP 484 进行了补充


  


  


  


  


，比如添加了变量注释     
     
     
     
 ，字面量注释这些东西

   

   

   

   

。

需要注意的是   




   




   




   




   ，类型提示仅有提示的作用



 



 



 



 



，这里的提示是指用户阅读Python代码的时候的提示                    ，仅在语法层面支持    




    




    




    




    ，对代码的运行没有任何影响























，Python 解释器在运行代码的时候会忽略类型提示                    ，也就是说     



     



     



     



    ，Python的类型提示仅是为了提升代码可读性






















，一定程度上缓解"动态语言一时爽
    
    
    
    
，代码重构火葬场"的尴尬     

     

     

     

  。

下面将函数注解和类型提示     


     


     


     


   ，统称为类型注解  




  




  




  




  
。

类型注解优点

1

   

   

   

   

、可以使Python拥有部分静态语言的特性 




 




 




 




 

，利用类型注解可以实现一种类似类型声明的效果

   

   

   

   

，提升代码的可读性及后续的可维护性


  


  


  


  


。

2     

     

     

     

  、类型注解可以让IDE（如pycharm）像静态语言那样分析我们的代码     

     

     

     

  ，及时给我们相应的提示  




  




  




  




  
，如下图对比：

VS

3  




  




  




  




  
、多多使用类型注解


  


  


  


  


，不仅可以让Python拥有强类型语言的严谨     
     
     
     
 ，还能保持Python作为动态类型语言的灵活性     
     
     
     
 。

普通变量类型注解

在声明变量时   




   




   




   




   ，变量的后面可以加一个冒号



 



 



 



 



，后面再写上变量的类型                    ，如 int


  


  


  


  


、list 等等    




    




    




    




    ，以此实现类型注解   




   




   




   




   。

a: int = 22 b: str = "name" c: float = 55.5 d: bool = True e: list = [1, 2, 3] f: set = {1, 2, 3} g: dict = {"name": "ming", "age": 22} h: tuple = (1, 2, 3) i: bytes = bworld j: bytearray = bytearray("world")

函数参数及返回值类型

函数参数的类型声明就是冒号+类型即可























，和普通变量类型声明没区别



 



 



 



 



。

函数返回值的类型声明是用箭头指向具体的类型                    ，如果是返回值有多个     



     



     



     



    ，使用元组包裹即可（因为函数的多个返回值就是以元组形式返回的）






















，需要注意的是
    
    
    
    
，箭头左右两边都要留有空格                    。

def handler(a: int, b: int) -> int: return a + b def handler2(a: int, b: int, *args: int) -> int: return a + b + sum(args) def handler3(a: int, b: int, *args: int, **kwargs: int) -> (int, str): return a + b + sum(args) + sum(kwargs.values()), ""

typing模块

typing模块的加入不会影响程序的运行     


     


     


     


   ，也不会报正式的错误 




 




 




 




 

，pycharm支持检测基于typing注解的错误

   

   

   

   

，不符合规定类型注解时会出现黄色警告     

     

     

     

  ，但不会影响程序运行    




    




    




    




    。

容器类型 & 复合类型

列表     
     
     
     
 、字典   




   




   




   




   、元组等包含元素的复合类型  




  




  




  




  
，用简单的 list


  


  


  


  


，dict     
     
     
     
 ，tuple 不能够明确说明内部元素的具体类型























。

此外   




   




   




   




   ，Python本身就是动态类型的语言



 



 



 



 



，如果我们强制使用某种类型                    ，一定程度上会丧失Python作为动态语言的优势    




    




    




    




    ，因此 typing 模块提供了一种复合类型注解的语法























，即一个参数即可以是类型A                    ，也可以是类型B或者类型C

from typing import Dict, List, Set, Tuple, Union # 字典 d: Dict[str, int] = {"a": 1, "b": 2} d1: Dict[str, int or str] = {"a": 1, "b": "2"} # 使用or表示支持多个类型 # 列表 l: List[int] = [1, 2, 3] l1: List[int or str] = [1, 2, "3"] # 元组 t: Tuple[str, int] = ("a", 1) # 代表了构成元组的第一个元素是 str 类型     



     



     



     



    ，第二个元素是 int 类型 t1: Tuple[str, ...] = ("a", "b", "c", "d", "e", "f", "g") # 代表接受多个 str 类型的元素 t2: Tuple[str or int, ...] = ("a", "b", 2) # 代表接受多个 str 或 int 类型的元素 # 集合 s: Set[int] = {1, 2, 3, 4} s1: Set[Union[int, str, float]] = {1, "2", 3.333, 4} # Union 同 or

TypedDict

TypedDict声明一个字典类型






















，该类型期望它的所有实例都有一组固定的keys
    
    
    
    
，其中每个key都与对应类型的值关联                    。

from typing import TypedDict class Student(TypedDict): name: str age: int height: float s1: Student = { "name": "xiao ming", "age": 22, "height": 55.5 } s2: Student = { "name": "xiao hong", "age": 21, }

可以看出     


     


     


     


   ，pycharm也会警告我们字典实例中缺失的key     



     



     



     



    。

同时 




 




 




 




 

，在我们生成字典实例的时候

   

   

   

   

，pycharm也会给我们key的提示






















。

类型别名

类型别名是通过将类型分配给别名来定义的     

     

     

     

  ，类型别名可用于简化复杂类型提示
    
    
    
    
。

from typing import Union Number = Union[int, float] def process(v: Number) -> Number: return v x: Number = 2 y: Number = 2.2 process(x) process(22) # 类型检查成功  




  




  




  




  
，类型别名和原始类型是等价的

NewType

使用NewType辅助类来创建不同的类型

from typing import NewType Number = NewType("Number", int) def process(v: Number) -> Number: return v x: Number = Number(22) process(x) process(22) # 类型检查异常：Expected type Number, got int instead # 原因就是NewType创建的是原始类型的“子类型    
    
    
    
   ”

因此


  


  


  


  


，类型别名 和 NewType 具体使用哪个     
     
     
     
 ，要视情况而定   




   




   




   




   ，不知道使用哪个



 



 



 



 



，可以先使用类型别名     


     


     


     


   。

NoReturn

当一个方法没有返回结果时                    ，为了注解它的返回类型    




    




    




    




    ，我们可以将其注解为 NoReturn 




 




 




 




 

。

因为Python 的函数运行结束时隐式返回 None 























，这和真正的无返回值是有区别的

   

   

   

   

。

from typing import NoReturn def process() -> NoReturn: pass

可选类型：Optional

使用 Optional[] 表示可能为 None 的值

from typing import Optional def handler(x: int) -> Optional[int]: if x % 2 == 0: return x

可调用对象：Callable

若一个变量类型是可调用函数                    ，则可以用 Callable[[Arg1Type, Arg2Type], ReturnType] 实现类型提示

from typing import Optional, Callable def handler(x: int) -> Optional[int]: if x % 2 == 0: return x def handler2(func: Callable[[int], Optional[int]]): pass handler2(handler)

字面量：Literal

指示相应的变量或函数参数只接收与提供的字面量(或多个字面量之一)等效的值     



     



     



     



    ，可以理解为规定了某个参数或变量的所有枚举值     

     

     

     

  。

from typing import Literal, NoReturn Mode = Literal["r", "w"] def process(mode: Mode) -> NoReturn: pass process("s")

可以看出






















，pycharm检查出了我们输入的值并不符合字面量规定的值
    
    
    
    
，进而出现了黄色警告  




  




  




  




  
。

Any

是一种特殊的类型     


     


     


     


   ，每种类型都视为与Any兼容 




 




 




 




 

，同样

   

   

   

   

，Any也与所有类型兼容


  


  


  


  


。可以对Any类型的值执行任何操作或方法调用     

     

     

     

  ，并将其分配给任何变量     
     
     
     
 。将Any类型的值分配给更精确的类型(more precise type)时  




  




  




  




  
，不会执行类型检查


  


  


  


  


，所有没有返回类型或参数类型的函数都将隐式地默认使用Any   




   




   




   




   。

使用Any     
     
     
     
 ，说明值是动态类型



 



 



 



 



。

把所有的类型都注解为 Any 将毫无意义   




   




   




   




   ，因此 Any 应当尽量少使用

from typing import Any def foo() -> Any: pass

抽象基类

# 在某些情况下



 



 



 



 



，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型 # 可以使用一个更为泛化的类型                    ，叫做 Sequence    




    




    




    




    ，其用法类似于 List class typing.Sequence(Reversible[T_co], Collection[T_co]) # collections.abc.Iterator的泛型版本 # 注释函数参数中的迭代类型时























，推荐使用的抽象集合类型 class typing.Iterable(Generic[T_co]) def print_iterable(x: Iterable): for i in x: print(i) # collections.abc.Mapping的泛型(generic)版本 # 注释函数参数中的Key-Value类型时                    ，推荐使用的抽象集合类型 class typing.Mapping(Sized, Collection[KT], Generic[VT_co])

泛型：TypeVar

先抛出问题：

假设有一个函数     



     



     



     



    ，要求它既能够处理字符串






















，又能够处理数字                    。那么你可能很自然地想到了 Union
    
    
    
    
，如下：

from typing import Union AddValue = Union[int, str] def add(a: AddValue, b: AddValue) -> AddValue: return a + b if __name__ == "__main__": print(add(1, 2)) # 类型检查通过     


     


     


     


   ，输出 3 print(add("1", "2")) # 类型检查通过 




 




 




 




 

，输出 12 print(add("1", 2)) # 类型检查通过

   

   

   

   

，报错 TypeError: can only concatenate str (not "int") to str

在类型检查通过的情况下     

     

     

     

  ，我们完成并运行了这段代码  




  




  




  




  
，可是代码却报错了！

原因就是我们的初衷是数字和数字相加实现求和


  


  


  


  


，字符串和字符串相加实现拼接     
     
     
     
 ，没有考虑到字符串与数字混用的问题   




   




   




   




   ，从而引发错误    




    




    




    




    。

根据以上问题



 



 



 



 



，我们可以引入泛型来解决这个问题：

from typing import TypeVar AddT = TypeVar("AddT", int, str) def add(a: AddT, b: AddT) -> AddT: return a + b if __name__ == "__main__": print(add(1, 2)) # 类型检查通过                    ，输出 3 print(add("1", "2")) # 类型检查通过    




    




    




    




    ，输出 12 print(add("1", 2)) # 类型检查失败























，pycharm告警 Expected type str (matched generic type AddT), got int instead

"""

通过告警                    ，我们提前发现了混用类型的问题     



     



     



     



    ，避免了程序运行时发生异常的可能























。

"""

泛型很巧妙地对类型进行了参数化






















，同时又保留了函数处理不同类型时的灵活性                    。

引用

1



 



 



 



 



、Python 标准库 typing 类型注解标注

2                    、Python类型注解
    
    
    
    
，你需要知道的都在这里了