Python基础-24 类型标注

24 类型标注

24.1 Python中的数据类型

    在Python中有很多数据类型，比较常见如下所示：

    因Python是弱类型语言，所以在实际写代码时，一般不去声明和定义参数的类型。示例如下：

def welcome(city):
   print(f\"welcome to {city}\")

    以上代码非常简单，就是输出一行欢迎标语。而在大家看到这个代码，也都默认了city是一个字符串类型(str)。

    现在我们来改造一下代码，将传入的city参数全部变为大写，代码如下所示：

def welcome(city):
   print(f\"welcome to {city.upper()}\")

以上代码在传入的city为字符串类型时，一切正常，但如果传入的是非字符串类型就会报错，例如传入123，便会出现如下所示的报错

AttributeError: \'int\' object has no attribute \'upper\'

24.2 指定类型

24.2.1 指定变量类型

24.2.1.1 指定变量类型

    针对以上问题，Python 3.5中引入了typing包，推荐使用类型标注，并且IDE会检查类型，让Python看起来有点像静态语言的感觉。

    那如何指定变量类型呢？只需要在变量名后 :类型 即可，如下所示：

def welcome(city:str):
   print(f\"welcome to {city.upper()}\")

24.2.1.2 变量类型声明的好与坏

    变量类型声明，对于之前有使用过强类型语言的人来讲，可能习以为常。但却对弱类型的语言，可能不太习惯，但确实还是有一些好处的。

• 以上面代码为例，如果定义为str类型，而实际传入为int时，PyCharm会进行相应的提示，不能这样做，如下所示：

• PyCharm会有更多提示

    在Python中，str类型的数据会有很多方法，而在指定数据类型后，PyCharm则会有更多提示，如下所示：

• 阅读代码方便，可以更快的知道需要传入什么类型的数据及返回的数据类型

    在指定变量的数据类型时，也是有一些坏处的，如下所示：

• 在编写代码，需要多写一些代码，看起来没有那么流畅
• 虽然指定的数据类型，但也仅仅是方便查看，并没有规定死变量类型，如指定为str类型，但传入int，依然可以运行代码，没有在运行层面进行检查

24.2.2 指定返回值类型

    在Python里面，方法/函数都是有返回值的，那么使用类型标的话，可以直接方法/函数末尾冒号之前添加 ->类型，示例如下所示：

def welcome(city:str)->str:
   return city.upper()

    这样做的好处跟之前示例一样，IDE可以更加智能提示，防止编写代码出错，如下所示：

    指定类型并不会影响编译结果，但也有很多好处，如下所示：

• 提高开发效率
• 降低出错率
• 阅读代码更友好

24.3 typing包

24.3.1 typing作用

    主要作用如下所示：

• 类型检查，防止运行时出现参数和返回值类型不符合
• 做为开发文档附加说明，方便调用者快速查看传入和返回数据类型
• 加入该模块后，不影响程序运行，仅有提醒

typing模块只有在Python 3.5 以上版本中才可以使用，PyCharm支持typing检查

24.3.2 typing包常见数据类型

常见的类型如上表格表示，如果需要使用List，Set，Dict，Union则需要导入typing

from typing import List,Set,Dict

24.3.3 typing包常见数据类型用法

• List

    List:列表，是list的泛型，基本等同于list，其后紧跟一个方括号，里面代表了构成这个列表的元素类型，示例如下所示：

from typing import List

# 基本声明
listSample:List[int or str]=[1,\"Surpass\"]
# 嵌套声明
listSample:List[List[int]]=[[1,2],[3,4]]

• Tuple

    Tuple:元组，是 tuple 的泛型，其后紧跟一个方括号，方括号中按照顺序声明了构成本元组的元素类型，如 Tuple[X, Y] 代表了构成元组的第一个元素是 X 类型，第二个元素是 Y 类型，示例如下所示：

from typing import Tuple

personInfo:Tuple[str,int,float,str]=(\"Surpass\",28,62.33,\"Shanghai\")

• Set/AbstractSet

    Set(集合)是set 的泛型，AbstractSet是 collections.abc.Set 的泛型。根据官方文档，Set 推荐用于注解返回类型，AbstractSet 用于注解参数，使用方法是后面跟一个中括号，里面声明集合中元素的类型,示例如下所示：

from typing import Set,AbstractSet

def SetSample(s:AbstractSet[int]) -> Set[int]:
    return  set(s)

• Dict/Mapping

    Dict(字典)是 dict 的泛型，Mapping(映射)是 collections.abc.Mapping 的泛型。根据官方文档，Dict推荐用于注解返回类型，Mapping 推荐用于注解参数。使用方法都是其后跟一个中括号，中括号内分别声明键名、键值的类型,示例如下所示：

from typing import Dict,Mapping

def DictSample(personInfo:Mapping[str,str])->Dict[str,str]:
    return {\"name\":personInfo[\"name\"],\"location\":personInfo[\"location\"]}

• Sequence

    Sequence是 collections.abc.Sequence 的泛型，在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表类型还是元组类型，则可以使用一个更为泛化的类型，叫做 Sequence，其用法类似于List,示例如下所示：

from typing import Sequence,List

def Square(ele:Sequence[int])->List[int]:
    return [i**2 for i in ele]

• NoReturn

    当一个方法没有返回结果时，为了注解它的返回类型，我们可以将其注解为 NoReturn,示例如下所示：

from typing import NoReturn

def hello(word:str)->NoReturn:
    print(word.title())

• Any

    Any是一种特殊的类型，它可以代表所有任意类型，静态类型检查器的所有类型都与 Any 类型兼容，所有的无参数类型注解和返回类型注解的都会默认使用 Any 类型。以下示例两种是完全等价相同的

from typing import Any

def hello(word):
    return word.title()

def hello(word:Any)->Any:
    return word.title()

• TypeVar

    TypeVar可以用来自定义兼容特定类型的变量，比如有的变量声明为int、float、str都是符合要求的，实际就是代表任意的数字或者字符串都是可以的，其他的类型则不可以。例如一个人的身高，便可以使用 int 或 float 或 None 来表示，但不能用 dict 来表示，所以可以这么声明：

from typing import TypeVar

Height=TypeVar(int,float,None)

def getHeight(height)->Height:
    return height

• NewType

    NewType，我们可以借助于其来声明一些具有特殊含义的类型，如前面Tuple示例，需要用来定义一个Person信息，但从表面上声明为Tuple不太直观，因此可以借助NewType来进行声明。示例如下所示：

from typing import NewType,Tuple

personInfo=NewType(\"PersonInfo\",Tuple[str,int,float,str])

person=personInfo((\"Surpass\",28,62.33,\"Shanghai\"))

示例中person就是一个tuple类型，跟其他tuple类型一样进行操作

• Union

    Union(联合类型)，Union[类型1,类型2] 代表要么是类型1类型，要么是类型2 类型。联合类型的联合类型等价于展平后的类型：

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]

from typing import Union

def getType(params:Union[int,str,float])->str:
    if isinstance(params,int):
        return f\"{params} type is int\"
    elif isinstance(params,float):
        return f\"{params} type is float\"
    elif isinstance(params,str):
        return f\"{params} type is str\"
    else:
        return f\"{params} type is unknown\"

• Optional

    Optional意思是说这个参数可以为空或已经声明的类型，即 Optional[类型1] 等价于 Union[类型1, None]

需要注意的是这个并不等价于可选参数，当它作为参数类型注解的时候，不代表这个参数可以不传递了，而是说这个参数可以传为 None。

from typing import Optional

def getInfo(data:Optional[int])->Optional[str]:
    if isinstance(data,int):
        return f\"INFO - {data} type is int\"
    elif data is None:
        return f\"WARNING -  {data} type is None\"
    else:
        return f\"ERROR - {data} type is not int,\"

原文地址：https://www.jianshu.com/p/5b135f8dec0d

本文同步在微信订阅号上发布，如各位小伙伴们喜欢我的文章，也可以关注我的微信订阅号：woaitest，或扫描下面的二维码添加关注：

作者：
Surpassme

来源：
http://www.jianshu.com/u/28161b7c9995/

        
http://www.cnblogs.com/surpassme/

声明：本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出
原文链接
，否则保留追究法律责任的权利。如有问题，可发送邮件 联系。让我们尊重原创者版权，共同营造良好的IT朋友圈。

来源：https://www.cnblogs.com/surpassme/p/16545609.html
本站部分图文来源于网络，如有侵权请联系删除。