🐍 让你的 Python 静态起来

为什么要 “静态”？

def get_weapons_status():
	weapon_status = {
		"LeviathanAxe": True,
		"BladesofChaos": False
	}
	return weapon_status,


weapons_status = get_weapons_status()
for weapon, status in weapons_status.items():
	if status:
		print(f"{weapon} is ready")

• 大幅度提升代码的可读性

• 能够将参数传递时的 类型错误 扼杀在摇(biān)篮(mǎ)中

• 能够最大程度利用 IDE 提供的代码提示，减少 typo

Typing Annotation

# 我们可以从类、模块、函数的 `__annotations__` 变量中获取这些注解
nine_realms: List[str] = ["Niflheim", "Muspelheim", "Asgard", "Midgard", "Jotunheim", "Vanaheim", "Alfheim", "Svartalfheim", "Helheim"]

class Yggdrasill:
	def transport(realm: str) -> bool:
		pass

类型注释？

pi = 3.142 # type: float

Gradual typing

Types 和 Classes

name: str = "Atreus"

from typing import List
names: List[str] = ["Atreus", "Loki"]

class Names(List[str]): ... # raises TypeError

各种使用场景

基本类型

def hey_boy(name: str) -> str:
return 'Boy: ' + name

容器类型

from typing import List

# 纯容器
def print_names(names: List) -> None:
	pass

# 容器 & 容器内元素
def print_names(names: List[str]) -> None:
	pass

print_names(['Kratos', 'Thor'])
print_names(['any_type', 128, {1, 2, 8}, (1, 2, 8)]) # 不被允许，容器内元素类型不一致

def print_names(names: Dict[str, str]) -> None:
	pass

print_names({'Blues': 'Yu'})

类型别名

from typing import Dict

Point = Dict[str: SomeObject]

def print_points(points: Dict[Point]):
	for point in points:
		print("X:", point[0], " Y:", point[1])

函数类型

from typing import Callable

def foo(func: Callable[[int], str], argument: str) -> None:
	print(func(argument))

def bar(name: int) -> str:
	return f"Hello {name}"

foo(create_greeting, "Jekyll")

“泛” 型

Any

from typing import TypeVar, AnyStr, Any

# 任意类型
# Any 兼容任意类型
def concat(a: Any, b: Any) -> Any:
	pass

TypeVar

# 任意字符型
# AnyStr = TypeVar('AnyStr', Text, bytes)

def concat(a: AnyStr, b: AnyStr) -> AnyStr:
	return a + b

concat(u"foo", u"bar") 
concat(b"foo", b"bar") 
concat(u"foo", b"bar")

# 以上三种写法都会被类型检查接受，但是运行时，最后一种调用会报错 `TypeError: can't concat str to bytes`

函数的“泛”型

from typing import overload, List


@overload
def switch_names(developers: str) -> List:
...


@overload
def switch_names(developers: List[str]) -> str:
...


# 这里不能有类型注解，并且需要实现一个通用的做法
def switch_names(developers):
	if isinstance(developers, str):
		# 例如 "ponyma,jackma,allenzhang"
		developers = developers.split(",")
		return developers
	elif isinstance(developers, List):
		# 例如 ["ponyma", "jackma", "allenzhang"]
		developers = ','.join(developers)
		return developers

# Union[X, Y] 意味着是 X 或 Y 类型
def switch_names(name: Union[str, List]):
	if isinstance(developers, str):
		# 例如 "ponyma,jackma,allenzhang"
		developers = developers.split(",")
		return developers
	elif isinstance(developers, List):
		# 例如 ["ponyma", "jackma", "allenzhang"]
		developers = ','.join(developers)
		return developers

Union 和 Optional

from typing import Union

# 通常的 Union 用法
def print_grade(grade: Union[int, str]):
	if isinstance(grade, str):
		print(grade + ' percent')
	else:
		print(str(grade) + ' percent')

# Optional[X] 相当于 Union[X, None]
from typing import Optional

def foo(optional_info: Optional[Dict] = None):
	return optional_info or {}

Django model

from typing import Union, List
from django.db.models import QuerySet
from my_app.models import MyModel

# 在后续代码中，records 的类型将被等同于 MyModel 的 QuerySet
# 不过同时需要注意，如果此时传入一个单纯的 List[MyModel]，
# 并调用 QuerySet 的方法，静态检查是不会探测出问题的
def foo(records: Union[QuerySet, List[MyModel]]):
	pass

Protocol

from typing import Union, Optional, Protocol

class Exitable(Protocol):
	def exit(self) -> int: ...

class Quittable(Protocol):
	def quit(self) -> Optional[int]: ...

def finish(task: Union[Exitable, Quittable]) -> int: ...

class QuitJob:
	def quit(self) -> int:
		return 0

class ExitJob:
	def exit(self) -> int:
		return 0

class Server: 
	def run_forever(self): -> NoReturn:
        """no return"""

finish(QuitJob()) # OK
finish(ExitJob()) # OK
finish(Server()) # Error

自定义类型

普通用法

from typing import Type

class User: ...
class BasicUser(User): ...
class ProUser(User): ...
class TeamUser(User): ...

# Accepts User, BasicUser, ProUser, TeamUser, ...
def make_new_user(user_class: Type[User]) -> User:
	return user_class()

类型自定义时

class Animal:
@classmethod
def newborn(cls, name: str) -> 'Animal':
	return cls(name, date.today())

TAnimal = TypeVar("TAnimal")

class Animal(Generic("TAnimal")):
	@classmethod
	def newborn(cls, name: str) -> TAnimal:
		return cls(name, date.today())

from datetime import date
from typing import Type, TypeVar

TAnimal = TypeVar("TAnimal", bound="Animal")

class Animal:
	@classmethod
	def newborn(cls: Type[TAnimal], name: str) -> TAnimal:
		return cls(name, date.today())

class Dog(Animal):
	def bark(self) -> None:
		print(f"{self.name} says woof!")

fido = Dog.newborn("Fido")
fido.bark()

辅助函数

from typing import NewType

UserId = NewType('UserId', int)
some_id = UserId(524313)

# 类型可以再次被创建
ProUserId = NewType('ProUserId', UserId)
some_pro_id = ProUserId(12345)

typing-extensions

pip install typing-extensions

实例：简化的枚举类型

from typing_extensions import Literal

# Literal 表示字面类型
def fetch_data(raw: Literal["red", "blue", "yellow"]) -> bytes: ...

工程技巧

避免循环引用

from B import AppFooController

class App:
	def __init__(name: str):
		self.name = name


def create_app():
	controller = AppFooController(App('bar'))

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from A import App
    
class AppFooController:
    # 注意：TYPE_CHECKING 语句下 import 的内容，都必须用引号包裹
    app: 'App'

mypy

pip install mypy

➜ mypy some-python-project-path/
foo/utils/sanitizer.py:18: error: Cannot find module named 'bleach.encoding'
foo/utils/sanitizer.py:19: error: Cannot find module named 'bleach.sanitizer'
foo/fake/tee/gitlab/client.py:5: error: Cannot find module named 'bar'
foo/fake/tee/gitlab/client.py:6: error: Cannot find module named 'bar'
foo/fake/tee/gitlab/client.py:7: error: Cannot find module named 'bar.objects'
foo/accessories/fake/tags.py:48: error: "type" has no attribute "tag_type"
foo/utils/log.py:4: error: Cannot find module named 'logstash'
foo/utils/log.py:5: error: No library stub file for module 'redis'
foo/utils/detector.py:32: error: Need type annotation for 'detect_map'
foo/utils/basic.py:3: error: Cannot find module named 'past.utils'
foo/utils/basic.py:9: error: Cannot find module named 'bar'
foo/utils/basic.py:10: error: Cannot find module named 'aenum'

➜ mypy tornado/
tornado/testing.py:263: error: Return type of "run" incompatible with supertype "TestCase"
tornado/testing.py:270: error: Incompatible return value type (got "Optional[TestResult]", expected "TestCase")

再让我们看看那个例子

结语

• Using Python's Type Annotations

• The Ultimate Guide to Python Type Checking

• PEP 483

• PEP 484

• PEP 544

• typing library