FastAPI从入门到实战（1）——Python类型提示

介绍

python不需要和其他编程语言那样，定义变量的时候直接指定int、float之类的类型，代码确实简洁了很多，但是代码量大起来之后，就会变的特别的繁杂，所以python提供的类型提示功能也就异常重要了。

• 类型提示是Python3.6+版本加入的功能；
• 类型提示就是在定义变量的时候给变量指定一个类型，比如定义一个str类型的变量；
• 类型提示在工程项目中很重要，配合静态检查、减少bug、方便开发；
• 类型提示使用简洁…

简单使用

• 编写一个简单的无提示的例子

def get_full_name(first_name, last_name):
    full_name = first_name.title() + " " + last_name.title()
    return full_name

print(get_full_name("john", "doe"))

运行输出：

John Doe

• 添加类型提示，将下面代码中的参数从：

first_name, last_name

改到：

first_name: str, last_name: str

完整代码：

def get_full_name(first_name: str, last_name: str):
    full_name = first_name.title() + " " + last_name.title()
    return full_name

print(get_full_name("john", "doe"))

• 使用方法总结：

  • 在变量或形参后面加上：，后面接类型就行，例如int 、float，就好了；

  • 返回值的类型提示就是在函数后面用箭头->指定；

    如：

  def get_full_name(first_name: str, last_name: str) -> str:
      full_name = first_name.title() + " " + last_name.title()
      return full_name
  

可以做什么

• 在IDE中写代码的时候，没有类型提示的时候，需要调用一个"将第一个字母转换为大写形式的方法"。输入函数的第一个参数 first_name，这个时候代码补全功能是起不了作用的；当给参数类型后，就能有完美的类型提示了；
• 其次就是知道了类型，在写代码的时候，就能很简明的发现其中的错误；
• 如上，声明类型提示的主要场景就是用于函数的参数，也是FastAPI中使用的主要场景。

简单类型

• int
• float
• bool
• bytes：代表字节串，是一个类型。字符串（str）由多个字符组成，以字符为单位进行操作；字节串（bytes）由多个字节组成，以字节为单位进行操作，由于 bytes 保存的就是原始的字节（二进制格式）数据，因此 bytes 对象可用于在网络上传输数据，也可用于存储各种二进制格式的文件，比如图片、音乐等文件。

def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):
    return item_a, item_b, item_c, item_d, item_d, item_e

嵌套类型

列表

from typing import List

def process_items(items: List[str]):
    for item in items:
        print(item)

以:声明变量

输入List作为类型

表示变量items是一个list，并且这个列表里每个元素都是str

元组和集合

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开，元组中的元素类型可以不相同;

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob') print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素 
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 
print (tuple[2:]) # 输出从第三个元素开始的所有元素 
print (tinytuple * 2) # 输出两次元组 
print (tuple + tinytuple) # 连接元组

集合(set)类似于数学中的集合：是一组key值，不包含重复元素，同时也是可变的、无序的、有限的集合，其元素是唯一的、不可变的。没有（不支持）索引和切片操作。

from typing import Set, Tuple

def process_items(items_t: Tuple[int, int, str], items_s: Set[bytes]):
    return items_t, items_s

上面这段代码表示：

变量items_t是一个tuple，其中前两个元素是int类型，最后一个元素是str类型；

变量items_s是一个set，其中的每个元素都是bytes类型。

字典

from typing import Dict

def process_items(prices: Dict[str, float]):
    for item_name, item_price in prices.items():
        print(item_name)
        print(item_price)

定义dict的时候，需要传入两个类型，分别声明键和值的类型；

上面代码表示：

变量prices是一个dict，这个dict的所有键都是str类型，所有的值都是float类型。

类

class Person:
    def __init__(self, name: str):
        self.name = name

def get_person_name(one_person: Person):
    return one_person.name

上面代码就表示one_person是一个Person类型的参数。

typing.Union

联合类型； Union[X, Y] 意味着：要不是 X，要不是 Y。

使用形如 Union[int, str] 的形式来定义一个联合类型。细节如下:

• 参数必须是类型，而且必须至少有一个参数。

• 联合类型的联合类型会被展开打平，比如:

  Union[Union[int, str], float] == Union[int, str, float]
  

• 仅有一个参数的联合类型会坍缩成参数自身，比如:

  Union[int] == int  # The constructor actually returns int
  

• 多余的参数会被跳过，比如:

  Union[int, str, int] == Union[int, str]
  

• 在比较联合类型的时候，参数顺序会被忽略，比如:

  Union[int, str] == Union[str, int]
  

• 你不能继承或者实例化一个联合类型。

• 你不能写成 Union[X][Y] 。

• 你可以使用 Optional[X] 作为 Union[X, None] 的缩写。

typing.Optional

可选类型。

Optional[X] 等价于 Union[X, None] 。

请注意，这与可选参数并非相同的概念。可选参数是一个具有默认值的参数。可选参数的类型注解并不因为它是可选的就需要 Optional 限定符。例如：

def foo(arg: int = 0) -> None:
    ...

另一方面，如果允许显式地传递值 None ， 使用 Optional 也是正当的，无论该参数是否是可选的。例如：

def foo(arg: Optional[int] = None) -> None:
    ...

例：

def foo_v1(a: int, b:int = None):
    if b:
        print(a + b)
    else:
        print("parameter b is a NoneType!")

def foo_v2(a: int, b: Optional[int] = None):
    if b:
        print(a + b)
    else:
        print("parameter b is a NoneType!")

def foo_v3(a: int, b: Union[int, None] = None):
    if b:
        print(a + b)
    else:
        print("parameter b is a NoneType!")

#只传入a位置的实参
foo_v1(2)
foo_v2(2)
foo_v3(2)

# 输出
>>> parameter b is a NoneType!
>>> parameter b is a NoneType!
>>> parameter b is a NoneType!

加不加Optional这个其实没什么区别，python会默认最后一个赋值的形式参数为可选参数，加上Optional这个参数主要是为了增加可读性，毕竟形如“int = None”的形式参数赋值容易引起歧义，也即类型注释已经为整数类型，但是你传入的参数确实None(也即‘NoneType’类型)，而添加Optional之后就相当于在int和None之间连接起来，也即默认是None，但是可以传入int类型的值(当然由于python没有强制，虽然注释为int类型，你还是可以传入其他类型)。

---

感谢阅读！
博客链接：https://blog.jiumoz.com/archives/fastapi-cong-ru-men-dao-shi-zhan-1python-lei-xing-ti-shi