## 变量

``````age: int = 1

child: bool
if age < 18:
child = True
else:
child = False
``````

## 常量

``````from typing import Final

RATE: Final = 3000

class Base:
DEFAULT_ID: Final = 0

RATE = 300  # Error: can't assign to final attribute
Base.DEFAULT_ID = 1  # Error: can't override a final attribute
``````

## 内置类型

``````from typing import List, Set, Dict, Tuple, Optional

x: int = 1
x: float = 1.0
x: bool = True
x: str = "test"
x: bytes = b"test"

# 集合类型是首字母大写的
# 元素的类型写在中括号里面（泛型）
x: List[int] = [1]
x: Set[int] = {6, 7}

# 字典需要写出 key 和 value 的类型
x: Dict[str, float] = {"field": 2.0}

# 元组需要写出所有元素的类型
x: Tuple[int, str, float] = (3, "yes", 7.5)

# 用 Optional[] 表示可以为 None 的类型
x: Optional[str] = some_function()
# mypy 可以推断出 if 语句里 x 不能为 None
if x is not None:
print(x.upper())
# 如果 x 的值不可能为 None, 用 assert
assert x is not None
print(x.upper())
``````

## 函数

``````from typing import Callable, Iterator, Union, Optional, List

def stringify(num: int) -> str:
return str(num)

def plus(num1: int, num2: int) -> int:
return num1 + num2

def f(num1: int, my_float: float = 3.5) -> float:
return num1 + my_float

# callable (函数) 类型
x: Callable[[int, float], float] = f

# 生成器函数会返回可迭代的元素
def g(n: int) -> Iterator[int]:
i = 0
while i < n:
yield i
i += 1
``````

## 类

``````from typing import ClassVar

class MyClass:
attr: int
# 实例变量可以有默认值
charge_percent: int = 100

# 什么也不返回，就是返回 None

def __init__(self) -> None:
...

# 实例方法，省略 self 的类型
def my_method(self, num: int, str1: str) -> str:
return num * str1

# 类可以用作类型
x: MyClass = MyClass()

# 类变量
class Car:
seats: ClassVar[int] = 4
passengers: ClassVar[List[str]]

# 需要注意还没定义就使用一个类会报错
def f(foo: A) -> int:  # Error
...

class A:
...

# 你可以使用字符串的形式来规避
def f(foo: "A") -> int:  # OK
...
``````

## Named tuples 命名元组

``````from typing import NamedTuple

class Point(NamedTuple):
x: int
y: int

p = Point(x=1, y="x")  # Error: Argument has incompatible type "str"; expected "int"
``````

## 异步迭代器

``````from typing import AsyncIterator

async def gen() -> AsyncIterator[bytes]:
lst = [b async for b in gen()]  # 推断类型是 "List[bytes]"
yield "no way"  # Error: Incompatible types (got "str", expected "bytes")
``````

## 类型别名

``````AliasType = Union[List[Dict[Tuple[int, str], Set[int]]], Tuple[str, List[str]]]

def f() -> AliasType:
...
``````

## Dataclasses 数据类

``````from dataclasses import dataclass, field

@dataclass
class Application:
name: str
plugins: List[str] = field(default_factory=list)

test = Application("Testing...")  # OK
bad = Application("Testing...", "with plugin")  # Error: List[str] expected
``````

## 泛型

``````from typing import TypeVar, Generic

T = TypeVar("T")

class Stack(Generic[T]):    # 泛型
def __init__(self) -> None:
self.items: List[T] = []

def push(self, item: T) -> None:
self.items.append(item)

def pop(self) -> T:
return self.items.pop()

def empty(self) -> bool:
return not self.items

# Stack[int] 实例
stack = Stack[int]()
stack.push(2)
stack.pop()
stack.push("x")        # Type error
``````

## Literal types

``````PrimaryColors = Literal["red", "blue", "yellow"]
SecondaryColors = Literal["purple", "green", "orange"]
AllowedColors = Literal[PrimaryColors, SecondaryColors]

def paint(color: AllowedColors) -> None: ...

paint("red")        # OK
paint("turquoise")  # Error
``````

## Protocol 协议

``````from typing import Iterable, Protocol

class SupportsClose(Protocol):
def close(self) -> None:
...  # 函数体可以为空 (explicit '...')

class Resource:  # 没有写 SupportsClose
def close(self) -> None:
self.resource.release()

def close_all(items: Iterable[SupportsClose]) -> None:
for item in items:
item.close()

close_all([Resource(), open("some/file")])  # OK
``````

## Abstractmethod 抽象方法

``````from typing import Protocol
from abc import abstractmethod

class Example(Protocol):
def first(self) -> int:
return 42

@abstractmethod
def second(self) -> int:  # 没有默认实现
raise NotImplementedError  # 防止这个方法被调用
``````

## Enum 枚举

``````from enum import Enum

class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3

print(Color.RED)
``````

## Python 静态类型检查 mypy 示例的更多相关文章

1. Java中静态类型检查是如何进行的

以下内容来自维基百科,关于静态类型检查和动态类型检查的解释: 静态类型检查:基于程序的源代码来验证类型安全的过程: 动态类型检查:在程序运行期间验证类型安全的过程: Java使用静态类型检查在编译期间 ...

2. Python静态代码检查工具Flake8

简介 Flake8 是由Python官方发布的一款辅助检测Python代码是否规范的工具,相对于目前热度比较高的Pylint来说,Flake8检查规则灵活,支持集成额外插件,扩展性强.Flake8是对 ...

3. 理解Flow静态类型检查

一.为什么在JavaScript中使用静态类型 了解静态类型的最快方法是将其与动态类型进行对比. 有静态类型参数的语言被称为静态类型语言. 另一方面,有动态类型参数的语言被称为动态类型语言.核心区别是 ...

4. 编译器开发系列--Ocelot语言6.静态类型检查

关于"静态类型检查",想必使用C 或Java 的各位应该非常熟悉了.在此过程中将检查表达式的类型,发现类型不正确的操作时就会报错.例如结构体之间无法用+ 进行加法运算,指针和数值之 ...

5. Flow: JavaScript静态类型检查工具

Flow: JavaScript静态类型检查工具 Flow是Facebook出品的,针对JavaScript的静态类型检查工具.其代码托管在github之上,并遵守BSD开源协议. 关于Flow 它可 ...

6. flow 静态类型检查 js

1.flow介绍 https://ustbhuangyi.github.io/vue-analysis/prepare/flow.html#为什么用-flow 2.使用 (1)安装flow (2)项目 ...

7. 如何使用flow进行静态类型检查

Flow 是 facebook 出品的 JavaScript 静态类型检查⼯具.Vue.js 的源码利⽤了 Flow 做了静态类型检查,所以了解 Flow 有助于我们阅读源码. 为什么⽤ Flow? ...

8. Python 加入类型检查

Python 是一门强类型的动态语言, 对于一个 Python 函数或者方法, 无需声明形参及返回值的数据类型, 在程序的执行的过程中, Python 解释器也不会对输入参数做任何的类型检查, 如果程 ...

9. flow JavaScript 静态类型检查工具

内置类型 flow 内置类型有 boolean, number, string, null, void, any, mixed, literal type. 其中 boolean, number, s ...

## 随机推荐

1. 适配iOS 10以及Xcode 8(转载)

一.证书管理 用Xcode8打开工程后,比较明显的就是下图了,这个是苹果的新特性,可以帮助我们自动管理证书.建议大家勾选这个Automatically manage signing(Ps.但是在bea ...

2. set -x 跟踪脚本执行信息

注意set -x其中"-"与"x"之间没有空格 [root@GitLab sh]# ./sx.sh heelo + a=heelo + echo heelo h ...

3. JS初级-作用域

作用域:域:空间.范围.区域--作用:读.写    script        全局变量.全局函数        自上而下        函数        由里到外        {}    浏览器 ...

4. ShortestPath:Silver Cow Party(POJ 3268)

牛的聚会 题目大意:一群牛在一块农田的不同的点,现在他们都要去到同一个地方开会,然后现在从那个地方回到原来的位置,点与点之间的连线都是单向的,并且通过一个路径需要一定时间,问你现在哪只牛需要最多的时间 ...

5. ThinkPHP常用变量

__ROOT__  : 网站根目录地址 __APP__  : 当前项目(入口文件)地址 __GROUP__:当前分组地址 __URL__  : 当前模块地址 __ACTION__ : 当前操作地址 _ ...

6. OC 数组

/*---------------------------创建数组------------------------------*/ //NSArray *array = [[NSArray alloc ...

7. Jquery中的重置

提交表单是像下面这样的:代码 \$('#myform').submit() \$('#myform').submit() 所以,想当然的认为,重置表单,当然就是像下面这样子喽:代码 \$('#myform ...

8. Aspnet Mvc 前后端分离项目手记（二）关于token认证