import sys
sys.platform
	# 操作系统名称
sys.maxsize
	# 当前计算机最大容纳“原生”整型
	# 一般就是字长
sys.version
	# python解释器版本号
sys.byteorder
	# 平台字节序
sys.hash_info
	# 数值类型hash信息

sys.getcheckinterval()
	# 查看解释器检查线程切换、信号处理器等的频率
sys.setcheckinterval(N)
	# 设置解释器检查线程切换、信号处理器等的频率

sys.hash_info.width
	# `hash()`函数截取hash值长度

sys.path

sys.modules
	# 已加载模块字典
sys.builtin_module_names
	# 可执行程序的内置模块
sys.getrefcount()
	# 查看对象引用次数

sys.exc_info()

sys.argv

sys.stdin
	# 标准输入流
sys.stdout
	# 标准输出流
sys.stderr
	# 标准错误流

stdin.read()
	# 从标准输入流引用对象读取数据
input("input a word")
sys.stdin.readlines()[-1]
	# 以上两行语句类似

stdin.isatty()
	# 判断stdin是否连接到终端（是否被重定向）

sys.exit(N)

sys.exitfuncs

sys.getdefaulencoding()
	# 文件内容编码，平台默认值
	# 默认输入解码、输出编码方案
sys.getfilesystemencoding()
	# 文件名编码，平台默认体系

os.environ
	# 获取、设置shell环境变量，类似字典
os.putenv()
	# 修改进程对应shell环境变量
os.getenv()

os.getpid()
	# 调用函数的进程id
os.getcwd()
	# 当前工作目录CWD
os.chdir(r"C:\Users")
	# 更改当前工作目录CWD

os.sep
	# python底层运行平台采用的**目录组**分隔符号
	# linux: `/`、win：`\`、某些mac：`:`
os.pathsep
	# 目录列表（字符串形式）中分隔目录的字符
	# posix机：`:`、win：`;`
os.curdir
	# 当前目录代表
	# linux：`.`
os.pardir
	# 父目录代表
	# linux：`..`
os.linesep
	# 换行符
	# linux：`\n`

os.path.isdir(r"C:\Users")
os.path.isfile(r"C:\Users")
	# 判断路径名是简单文件、目录
os.path.exists(r"C:\Users")
	# 判断路径名是否存在

pfile = os.path.join(r"C:\temp", "output.txt")
	# 连接文件名、目录

os.path.split(pfile)
	# 分离文件名、目录

os.path.dirname(pfile)
	# 返回路径中目录
os.path.basename(pfile)
	# 返回路径中
os.path.splitext(pfile)
	# 返回文件扩展名

os.path.normpath(r"C:\temp/index.html")
	# 调整路径为当前平台标准，尤其是分隔符混用时
os.path.abspath("index.html")
	# 返回文件的**完整绝对路径名**
	# 扩展`.`、`..`等语法

os.mkdir(dirname)
os.rename(ori_name, dest_name)
os.remove(filename)
os.unlink(filename)
	# unix下文件删除，同`os.remove`
os.chmod(filename, previlideges)
info = os.stat(filename)
	# 命名元组表示的文件底层信息
	# 可使用`stat`模块处理、解释信息
os.listdir(dirpath)
os.walk(rootdir, topdown=True/False)
	# 遍历根目录下的整个目录树

descriptor = os.open(path, flags, mode)
	# 打开文件并返回底层描述符
os.read(descriptor, N)
	# 最多读取N个字节，返回一个字节串
os.write(descriptor, string)
	# 将字节串写入文件
os.lseek(descriptor, position, how)
	# 移动文件游标位置
descriptor.flush()
	# 强制刷出缓冲

new_fd = os.dup(fd)
	# 创建文件描述符副本
os.dup2(fd_src, fd_dest)
	# 将文件描述符`fd_src`复制至`fd_dest`

import traceback, sys

try:
	...
except:
	exc_info = sys.exec_info()
	print(exec_info[0], exec_info[1])
	traceback.print_tb(exec_info[2])

import stat

info = os.stat(filename)
info[stat.ST_MODE]
	# `stat.ST_MODE`就是字符串
	# 只是这样封装易于跨平台
stat.S_ISDIR(info.st_mode)
	# 通过整数`info.st_mode`判断是否是目录

import glob

def glob.glob(pathname,*,recursive=False)

import struct
data = struct.pack(">i4shf", 2, "spam", 3, 1.234)
	# `>`：高位字节优先，大端
	# `i`：整形数据
	# `4s`：4字符字符串
	# `h`：半整数
	# `f`：浮点数
file = open("data.bin", "wb")
file.write(data)
	# 二进制写入字节串
file.close()

file = open("data.bin", "rb")
bytes = file.read()
values = struct.unpack(">i4shf", data)
	# 需要给出字节串存储格式

def dis.dis(func)
	# 打印可拆解函数语句对应机器指令

def register(
	func,
	*arg,
	**kwargs
)

import atexit

df func1():
	print("atexit func 1, last out")

def func2(name, age):
	print("atexit func 2")

atexit.register(func1)
atexit.register(func2, "john", 20)

@atexit.register
def func3():
	print("atexit func 3, first out")

from functools import total_ordering

class Room:
	def __init__(self, name, length, width):
		self.name = name
		self.length = length
		self.width = width
		self.square_feet = self.length * self.width

@total_ordering
class House:
	def __init__(self, name, style):
		self.name = name
		self.style = style
		self.rooms = list()

	@property
	def living_space_footage(self):
		return sum(r.square_feet for r in self.rooms)

	def add_room(self, room):
		self.rooms.append(room)

	def __str__(str):
		return "{}: {} squre foot {}".format(
			self.name,
			self.living_space_footage,
			self.style)

	def __eq__(self, other):
		return self.living_space_footage == other.living_space_footage

	def __lt__(self, other):
		return self.living_space_footage < other.living_space_footage

os.startfile(filename)
	# 调用系统默认程序打开文件，类似于鼠标双击
	# linux下没有实现
int = os.system(command(str))
	# 运行shell命令，返回命令执行退出状态
	# 和普通shell命令一样默认阻塞，除非后台运算符`&`

pipe = os.popen(cmd(str), mode="r"/"w", buffering=-1)
	# 运行shell命令并重定向其输出、输入流到管道开放

def execv(path, args=tuple/list)
def execl(path, *args=*list/*tuple)
	# 以参数执行指定可执行文件，**代替**当前进程

def execvp(file, args)
def execlp(file, *args)
	# `p` for `$PATH`
	# 在系统搜索路径`$PATH`中定位可执行程序

def execve(path, args=tuple/list, env=dict)
def execle(path, args=*tuple/*list, env=dict)
	# `e` for `environ`
	# 将`env`字典作为环境环境变量传递

def execvpe(path, args=tuple/list, env=dict)
def execlpe(path, args=*tuple/*list, env=dict)
	# 在系统搜索路径`$PATH`中定位可执行程序
	# 将`env`字典作为环境环境变量传递

os.spawn
	# 启动带有底层控制的新程序

read_fd, write_fd = os.pipe()
	# 创建管道，返回管道写入、读取描述符
	# 可以使用`os.fdopen()`封装管道描述符，方便读、写
os.mkfifo(path, mode=438, *, dir_fd=None)
	# 创建命名管道，win不支持
	# 仅创建外部文件，使用需要像普通文件一样打开、处理

class Popen:
	def __init__(self,
		args(str,[str]),
		bufsize=-1/0/1/int,
		executable=None/str,
		stdin=None/stream,
		stdout=None/stream,
		stderr=None/stream,
		preexec_fn=None/callable,
		close_fd=obj,
		shell=False/True,
		cwd=None/path,
		env=None/dict,
		universal_newlines=False/True,
		startupinfo=None,
		creationflags=0,
		restore_signals=True/False,
		start_new_session=False/True,
		pass_fds=(),
		encoding=None/str,
		errors=None
	)

(stdout, stderr) = communicate(self, input=None, timeout=None)

def kill(self):
	# kill进程通过*SIGKILL*信号

def terminate(self):
	# 终止进程通过*ISGTERM*信号

def send_signal(self, sig):
	# 向进程传递信号

def poll(self):
	# 检查子进程是否终止，设置、返回`.returncode`属性

def wait(self, timeout=None, endtime=None):
	# 等待直到子进程终止，返回`.returncode`属性

pipe.stdin
pipe.stdout
pipe.stderr
	# 管道标准输入、输出、错误流
	# 创建子进程时，可以选择和子进程相应流连接
	# 支持读、写、迭代
pipe.returncode
	# 子进程退出状态

subprocess.call(
	"type hello.py",
	shell=True/False
)

Lock = _thread.alloacate_lock()
	# 获取一个`Lock`锁
	# 等价于`threading.Lock()`
Lock = _thread.allocate()
	# deprecated，同上

RLock = _thread.RLock()
	# 获取一个`RLock`可重入锁
	# 等价于`threading.RLock()`

def _thread.exit()
	# 退出当前线程，可捕捉
	# 等价于显式`raise SystemExit`、`sys.exit()`
def _thread.exit_thread()
	# 同上

import _thread as thread

stdoutmutex = thread.allocate_lock()
	# 创建全局标准输出锁锁对象
exitmutexes = [thread.allocate_lock() for _ in range(10)]
	# 为每个线程创建锁
exitmutexes_bool = [False] * 10
	# 线程共享内存，同样可以使用全局变量作为信号量，而不用
		# 额外开销

def counter(myId, count):
	for i in range(count):

		stdoutmutex.acquire()
			# 线程向标准输出流写入时，获得锁
		print("[%s] => %s" % (myId, i))
		stdoutmutex.release()
			# 向标准输出流写入完毕后，释放锁

		with stdoutmutex:
			# 线程锁同样支持`with`上下文管理器
			print("[%s] => %s again" % (myId, i))

	exitmutexes[myID].acquire()
		# 线程执行完毕后获取对应自身id的锁，通知主线程

for i in range(10):
	thread.start_new_thread(counter, (i, 100))
	# 创建、启动新线程

for mutex in existmutexes:
	# 检查所有信号锁
	while not mutex.locked():
		# 直到信号锁被获取，结束死循环
		pass
print("main thread exiting")

import _thread as thread
import time

stdoutmutex = thread.allocate_lock()
exitmutexes_bool = [False] * 10

def counter(myId, count):
	for i in range(count):
		with stdoutmutex:
			# 线程锁同样支持`with`上下文管理器
			print("[%s] => %s again" % (myId, i))
	exitmutexes[myID] = True

for i in range(10):
	thread.start_new_thread(counter, (i, 100))

while not all(exitmutexes):
	time.sleep(0.25)
	# 暂停主线程，减少占用CPU进行无价值循环
print("main thread exiting")

class Thread:
	def __init__(self,
		group=None,
		target=callable,
		name=None/str,
		args=(),
		kwargs={},
		*,
		daemon=None/True/daemon):
		pass

def run(self):
	pass

def start(self):
	pass

def join(self,
	timeout=None/float):
	pass

bool = is_alive(self):
	# 返回线程是否存活

def setDaemon(self, daemonic):
	# 设置守护进程
bool = isDaemon(self):

def setName(self, name):
	# 设置线程名
def getName(self):

class Event():
	def set(self):
		# 设置信标值为`True`，发送信号

	bool = is_set(self):
		# 查看信标是否被设置

	bool = wait(self, timeout):
		# 阻塞，直到超时、信标被设置为`True`
		# 返回信标值，即因超时返回时返回`False`

	def clear():
		# 重置Event对象，设置信标值为`False`

class Condition():
	def __init__(self, lock=None)
		# `lock`：`Lock`、`RLock`对象，被用作底层锁
		# 缺省创建新`RLock`对象作为底层锁

	bool accquire():
		# 获取一次condition内部锁

	bool release():
		# 释放一次condition内部锁

	def notify(self, n=1):
		# 唤醒至多`n`个on this condition的线程

	def notify_all(self):
		# 唤醒所有on this condition的线程

	bool = wait(self, timeout=None):
		# 释放底层锁，阻塞
		# 直到被唤醒再次获取底层锁、超时，返回

	bool = wait_for(self, predicate(callable), timeout=None):
		# `wait`直到`predicate`返回`True`

with c:
	c.wait()

with c:
	c.notify()

class Semaphore(builtins.object):
	def __init__(self, value):
		# `value`：起始许可证数量（最多允许同时执行线程数目）

	bool = acquire(self, blocking=True, timeout=None):
		# 获取信号量，内部计数（许可证）减1

	def release():
		# 释放信号量，内部计数（许可证）加1

class BoundedSemaphore(Semaphore):
	def release(self):
		# 释放信号量，内部计数加1
		# 当信号量总数超过初始化值时`raise ValueError`

class lock:
	bool = acquire(blocking=True/False, timeout=-1)
		# 尝试获得锁，返回是否获得锁
	bool = acquire_lock
		# deprecated，同`acquire`

	bool = locked()
		# 返回锁状态
	bool = lockec_lock()
		# deprecated，同`lock`

	bool = release()
		# 释放锁，若锁本身未获取`raise RuntimeError`
	bool = release_lock()
		# deprected，同`release`

class RLock:
	bool =  acquire(block=True):
		# 尝试获取锁，返回是否获取锁
		# 每次获取锁，内部计数器加1
	bool = release()
		# 释放锁，若锁本身未获取`raise RuntimeError`
		# 每次释放锁，内部计数器减1

from threading import Thread
import time

class CountDownTask:

	def __init__(self):
		self._running = True

	def terminate(self):
		self._runing = False

	def run(self, n):
		while self._running and n > 0:
			# 设置轮询点，告诉线程何时应该终止
			print("T-minus", n)
			n -= 1
			time.sleep(5)

def test():
	c = CountdownTask()
	t = Thread(karget=c.run, args=(10,0))
		# 创建Thread
	t.start()
		# 启动线程
	c.terminate()
	c.join()

class IOTask:
	def terminate(self):
		self._running = False
	
	def run(self, sock):
		sock.settimeout(5)
			# 设置超时
		while self._running:
			try:
				data = sock.recv(8192)
				break
			except socket.timeout:
				continue
			...continued processing...
		...terminated...
		return

from threading import Event, Threading

def send_signal(start_evt):
	start_evt.set()
		# 设置事件

def recv_signal():
	start_evt = Event()
		# 创建新事件
	t = Thread.threading(target=send_signal, start_evt)
	start_evt.wait()
		# 阻塞直到接收到信号

import heapq
from threading import Condition

class PriortyQueue:
	def __init__(self):
		self._queue = [ ]
		self._count = 0
		self._cv = Condition()
			# 封装`Condition`实例实现线程间同步

	def put(self, item, priority):
		with self._cv:
			heapq.heappush(self._queue, (-priority, self._count, item))
			self._count += 1
			self._cv.notify()

	def get(self):
		with self._cv:
			# 阻塞，直到空闲
			while len(self._queue) == 0:
				self._cv.wait()
				# `Condition`默认使用`RLock`，可重入
			return heapq.heappop(self._queue)[-1]

from threading import local
from contextlib import contextmanager

_local = local()

@contextmanager
	# 使支持`with`上下文管理器语法
def acquire(*locks):

	locks = sorted(locks, key=lambda x: id(x))
		# 根据*object identifier*对locks排序
		# 之后根据此list请求锁都会按照固定顺序获取

	acquired = getattr(_local, "acquired", [ ])
		# 为每个线程创建独立属性保存锁
	if acquired and max(id(lock)) for lock in acquired >= id(locks[0]):
		# `_local`中已有锁不能比新锁`id`大，否则有顺序问题
		raise RuntimeError("lock order violation")

	acquired.extend(locks)
	_local.acquired = acquired
		# 更新线程环境中锁

	try:
		for lock in locks:
			# 只允许升序获取锁
			lock.acquire()
		yield
			# `with`语句进入处
	finally:
		# `with`语句退出处
		for lock in reversed(locks):
			# 只允许降序释放锁
			lock.release()
		del acquired[-len(locks):]

def thread_1(x_lock, y_lock):
	while True:
		with acquire(y_xlock, y_lock):
			print("Thread_1")

def thread_2(x_lock, y_lock):
	while True:
		with acquire(y_lock, x_lock):
			print("Thread_2")

def test():
	x_lock = threading.Lock()
	y_lock = threading.Lock()

	t1 = threading.Thread(target=thread_1, args=(x_lock, y_lock)):
	t1.daemon = True
	t1.start()

	t1 = threading.Thread(target=thread_2, args=(x_lock, y_lock))
	t2.daemon = True
	t2.start()

class Queue(builtins.object):
	def __init__(self, maxsize=0):
		# `maxsize`；限制可以添加到队列中的元素数量

obj =  get(self,
	block=True,
	timeout=None/num)

obj =  get_nowait(self):
	# 等同于`get(block=False)`

def task_done(self):
	# 指示前一个队列“任务”完成
def join(self):
	# 阻塞直到队列中所有元素被获取（消费）、**处理**

def put(self,
	item,
	block=True,
	timeout=None/num):
	pass

def put_nowait(self, item):
	# 等价于`put(self, item, block=False)`

int = qsize(self):
	# 返回队列大概大小（不可靠）
	# 非线程安全，在其使用结果时队列状态可能已经改变

bool = empty(self):
	# deprecated，使用`qsize() == 0`替代
	# 和`qsize()`一样非线程安全

bool = full(self):
	# deprecated，使用`qsize() > n`替代，非线程安全

from queue import Queue
from threading import Thread, Event

def producer(out_q):
	while running:
		evt = Event()
		out_q.put((data, evt))
			# 将`Event`实例放入队列
		evt.wait()
			# 阻塞直到收到消费者信号

 # A thread that consumes data
def consumer(in_q):
	while True:
		data, evt = in_q.get()
		evt.set()
			# 告知生产者消费完成

_sentinel = object()

def producer(out_q):
	while running:
		out_q.put(data)
	out_q.put(_sentinel)
		# 将特殊值放入队列，结束生产、通知消费者
def consumer(in_q):
	while True:
		data = in_q.get()
		if data is _sentinel:
			# 消费者接收到特殊值，结束生产
			in_q.put(_sentinel)
				# 特殊信号放回队列，继续传递
			break

from socket import socket, AF_INET, SOCK_STREAM
from threading import Thread
from queue import Queue

def echo_client(q):
	sock, client_addr = q.get()
	while True:
		msg = sock.recv(65536)
		if not msg:
			break
		sock.sendall(msg)
	print("closed")

def echo_server(addr, nworkers):
	q = Queue()
	for n in range(nworkers):
		t = Thread(target=echo_client, args=(q,))
		t.daemon = True
		t.start()
	socket = socket(AF_INET, SOCK_STREAM)
	socket.bind(addr)
	sock.listen(5)
	while True:
		client_sock, client_addr = sock.accept()
		q.put((client_sock, client_addr))

class Process():
	def __init__(self,
		group=None,
		target=None/callable,
		name=None/str,
		args=()/list,
		kwargs={}/dict,
		daemon=None
	):
		self.authkey
		self.daemon
		self.exitcode
		self.name
		self.pid

	def is_alive(self):

	def join(self,
		timeout=None/num
	):

	def start(self):
		# 启动进程

	def run(self):
		# `start`方法调用`run`方法，若进程实例未传入`target`，
		# `start`默认执行`run`方法

	def terminate():
		# 立即结束进程

from multiprocessing import Process
import os

def test(name):
	print("Process ID: %s" % (os.getpid())
	print("Parent Process ID: %s" % (os.getppid()))

if __name__ == "__main__":
	proc = Process(target=test, args=("nmask",))
	proc.start()
	proc.join()

class Pool:
	def __init__(self,
		processes=None/int,
		initializer=None,
		initargs=(),
		maxstacksperchild=None/int,
		context=None
	):

def apply(self, func, args=(), kwds={}):
	# 分配进程执行`func(*args, **kwds)`，阻塞
	# 返回值：`func(item)`返回值

def apply_async(self, func, args=(), kwds={},
	callback=None, error_callback=None)
	# 异步分配进程执行调用，非阻塞
	# 返回值：`ApplyResult`对象

class ApplyResult:
	def __init__(self, cache, chunksize, length,
		callback, error_callback):

	def get(self, timeout=None):

	bool = ready(self):

	bool = successful(self):

	bool = wait(self, timeout=None):

def map(self, func, iterable, chunksize=None):
	# 同步多进程`map(func, iterable)`，阻塞直到全部完成
	# 返回值：结果列表，结果按调用顺序

def map_async(self, func, iterable, chunksize=None,
	callback=None, error_callback=None):
	# 异步多进程`map`，非阻塞
	# 返回值：`MapResult(ApplyResult)`对象

def imap(self, func, iterable, chunksize=1):
	# 迭代器版`map`，更慢、耗内存更少
def imap_unordered(self, func, iterable, chunksize=1):
	# 返回结果无序版`imap`

def starmap(self, func, iterable, chunksize=1):
	# 同步`map`，参数被解构`func(*item)`，阻塞

def starmap_async(self, func, iterable, chuncksize=None,
	callback=None, error_callback=None):
	# 异步`startmap`，阻塞

def close(self):
	# 关闭进程池，不允许添加新进程

def join(self):
	# 阻塞，直至进程池中所有进程执行完毕
	# 必须先`.close`进程池

def terminate(self):
	# 终止进程池

class SimpleQueue():
	bool empty(self):
	def get(self):
	def put(self):
class Queue:
	def __init__(self, maxsize=0, *, ctx):
	def join_thread(self):
		# join feeder线程
	def cancel_join_thread(self):
		# 控制在进程退出时，不自动join feeder线程
		# 有可能导致部分数据在feeder中未被写入pipe而丢失
	def close(self):
		# 关闭feeder线程
	def qsize(self):
	def empty(self):
	def full(self):
	def get(self, block=True, timeout=None):
	def get_nowait(self):
	def put(self, obj, block=True, timeout=None):
	def put(self):
class JoinableQueue(Queue):
	def task_done():
	def join():

class Connection():
	def __init__(self, handle,
		readable=True,
		writable=True):

	def close(self):
	def fileno(self):
		# 返回描述符或连接处理器
	bool = poll(self, timeout=0):
		# 是否有输入可以读取
	obj =  recv(self):
		# 接收pickable对象
		# 若接收字节流不能被pickle解析则报错
	bytes = recv_bytes(self, maxlength=None):
		# 接收字节流作为`bytes`
	int = recv_bytes_into(self, buf, offset=0):
		# 接收字节流存入可写`buf`
		# 返回读取的字节数量
	def send(self, obj):
		# 发送对象
	def send_bytes(self, buf, offset=0, size=None):
		# 发送bytes-like对象中字节数据

class SynchronizedBase:
	def __init__(self, obj, lock=None, ctx=None):

	def get_lock(self):
		# 获取`multiprocessing.synchronize.RLock`

	def get_obj(self):
		# 获取数据对象，C数据结构`ctypes.`

def Value(typecode_or_type, *args, lock=True):
	# 返回同步共享对象
class Synchronized(SynchronizedBase):
	value

def Array(typecode_or_type, size_or_initializer, *,
	lock=True)

def SynchronizedArray(SynchronizedBase):
	def __getitem__(self, i):
	def __getslice__(self, start, stop):
	def __len__(self):
	def __setitem(self, i, value):
	def __setslice__(self, start, stop, values):

import multiprocessing as mltp
l1 = mltp.Lock()
	# 获取进程锁
rl1 = mltp.RLock()
	# 获取可重入锁
s1 = mltp.Semaphore(value=int)
	# 获取信号量对象
bs1 = mltp.BoundedSemaphore(value=int)
	# 获取有上限信号量对象
e1 = mltp.Event()
	# 获取事件对象
cv1 = mltp.Condition(lock=None)
	# 获取Condition对象
cp = mltp.current_process()
	# 获取当前Process对象

class ThreadPoolExecutor:
	def __init__(self,
		max_workers=None,
		thread_name_prefix=''):

	def shutdown(self, wait=True):
		# 清理和该执行器相关资源

	def submit(self, fn(callable), *args, **kwargs):
		# 以指定参数执行`fn`
		# 返回：代表调用的future，可以用于获取结果

	def map(self, fn, *iterables,
		timeout=None,
		chunksize=1/int)
		# 并行`map(fn, iterables)`
		# 返回：按调用顺序的结果迭代器

class ProcessPoolExecutor:
	def __init__(self,
		max_workers=None):

	def shutdown(self, wait=True):
		# 清理和该执行器相关资源

	def submit(self, fn(callable), *args, **kwargs):
		# 以指定参数执行`fn`
		# 返回：代表调用的`Future`实例，可以用于后续处理

	def map(self, fn,
		*iterables,
		timeout=None,
		chunksize=1/int)
		# 并行`map(fn, iterables)`
		# 返回：按调用顺序的结果迭代器

class Future:
	def add_done_callback(self, fn):
		# 添加future完成的回调函数
		# 多次调用添加的回调函数按添加顺序执行

	bool =  cancel(self):
		# 尝试取消当前future，返回是否成功取消
		# 正在运行、执行完成的future不能被取消

	bool = cancelled(self):
		# 查看当前future是否被取消

	bool = done(self):
		# 查看当前future是否被取消、完成

	def exception(self, timeout=None):
		# 返回当前future代表的调用的exception

	def result(self, timeout=None):
		# 返回当前future代表调用的返回值

class = type(
	name=cls_name,
	bases=(pls_name,..),
	dict={attr1: val1,...}
)