Python3
{Back to Index}  Expand All Details on Page

元组通常被用作 不可变的列表 。 但元组的意义是 对数据的记录 ：元组中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。 正是这个位置信息给数据赋予了意义。

from collections import namedtuple
City = namedtuple('City', 'name country population coordinates')
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
log("tokyo", tokyo)
log("tokyo.population", tokyo.population)
log("tokyo.coordinates", tokyo.coordinates)
log("tokyo[1]", tokyo[1])

=========== tokyo ============
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))
====== tokyo.population ======
36.933
===== tokyo.coordinates ======
(35.689722, 139.691667)
========== tokyo[1] ==========
JP

除了从普通元组继承来的属性之外，具名元祖还有一些自己专用的属性：

log("City._fields", City._fields)

LatLong = namedtuple('LatLong', 'lat long')
delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
delhi = City._make(delhi_data)
log("delhi._asdict()", delhi._asdict())
print()
for key, value in delhi._asdict().items():
    print(key + ':', value)

======== City._fields ========
('name', 'country', 'population', 'coordinates')
====== delhi._asdict() =======
OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population', 21.935), ('coordinates', LatLong(lat=28.613889, long=77.208889))])

name: Delhi NCR
country: IN
population: 21.935
coordinates: LatLong(lat=28.613889, long=77.208889)

切片操作里不包含区间范围的最后一个元素是 Python 的风格，这个习惯带来的好处如下：

• 当只有最后一个位置信息时，可以快速看出有几个元素： range(3) 和 my_list[:3] 都返回 3 个元素
• 当起止位置信息都可见时，可以快速计算出区间长度，即 stop - start
• 可以利用任意一个下标把序列分割成不重叠的两部分，只需写成： my_list[:3] 和 my_list[3:]

如果需要一个只包含数字的列表，使用 array.array 比 list 更高效。

创建数组需要一个类型码，用来表示底层的 C 语言应存放怎样的数据类型。

from array import array
from random import random
floats = array('d', (random() for i in range(1000)))  # 'd' 表示双精度浮点
log("floats[-1]", floats[-1])

========= floats[-1] =========
0.970088201571867

memoryview 是一个内置类，能让用户在 不复制内容的情况下 ，在数据结构之间 共享内存 。

# 通过改变数组中的一个字节来更新数组里某个元素的值
import array
numbers = array.array('h', [-2, -1, 0, 1, 2])  # 'h' 表示 16 位二进制整数
memv = memoryview(numbers)

# memoryview.cast 会把同一块内存里的内容打包成一个全新的 memoryview
memv_oct = memv.cast('B')   # 'B' 表示无符号字符
memv_oct[5] = 4

log("numbers", numbers)

========== numbers ===========
array('h', [-2, -1, 1024, 1, 2])

collection.deque 是一个 线程安全 ，可以快速从两端添加或删除元素的数据类型。

如果想要一种数据结构来存放 最近用到的几个元素 ，deque 是一个很好的选择。

from collections import deque
dq = deque(range(10), maxlen=10)
log("dq", dq)

dq.rotate(3)
log("dq.rotate(3)", dq)

dq.rotate(-4)
log("dq.rotate(-4)", dq)

dq.appendleft(-1)
log("dq.appendleft(-1)", dq)

dq.extend([11, 22, 33])
log("dq.extend([11, 22, 33])", dq)

============= dq =============
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
======== dq.rotate(3) ========
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
======= dq.rotate(-4) ========
deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
===== dq.appendleft(-1) ======
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
== dq.extend([11, 22, 33]) ===
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)

映射类型在处理找不到的键的时候，都会涉及__missing__方法。 虽然基类 dict 没有定义这个方法，但是如果一个类继承了 dict ，然后提供了__missing__方法， 那么当__getitem__遇到找不到键的时候，Python 会自动调用它，而不是抛出 KeyError 异常。

missing 方法只会被__getitem__调用（即使用表达式 d[k] ）

散列表是一个 稀疏数组 (总是有空白元素的数组称为稀疏数组)。散列表中的单元叫做 bucket 。 每个 bucket 分为两部分，一个是键的引用，一个是值的引用。

Python 会设法保证大概还有三分之一的 bucket 是空的，所以在快要到达这个阈值的时候， 原有的散列表会被复制到一个更大的空间里面 。

• 合集： a | b
• 交集： a & b
• 差集： a - b

在计算机内存中，统一使用 Unicode 编码，当需要保存到硬盘或者需要传输的时候，就转换为 UTF-8 编码。

Python 的字符串在内存中以 Unicode 表示 ，一个字符对应若干个字节。 如果要在网络上传输，或者保存到磁盘上， 就需要把字符串变为以字节为单位的 bytes 。

仅限关键字参数可以用于限制关键字参数的名字。调用时必须传入参数名，否则将报错。

定义函数时若想指定 仅限关键字参数 ，要把它们放到前面有 * 的参数后面。

如果不想支持数量不定的定位参数，但是想支持仅限关键字参数，在函数签名中放一个 * 即可：

def f(a, *, b):
    return a, b

print(f(1, b=3))

(1, 3)

如果函数定义中已经有了一个可变参数，后面跟着的仅限关键字参数就不再需要分隔符 * ：

def f(a, *b, c):
    return (a, b, c)

print(f(1, 2, 3, c=4))

(1, (2, 3), 4)

定义默认参数时，默认参数必须指向不可变对象。

def add_end(L=[]):
    L.append('END')
    return L

print(add_end())
print(add_end())
print(add_end())

['END']
['END', 'END']
['END', 'END', 'END']

出现这种现象的原因在于， 函数在定义的时候，默认参数 L 的值就被计算出来了，即 [] ，且该 引用 保存在函数属性__defaults__中。 每次调用该函数，如果改变了 L 的内容，__defaults__中的内容 也将随之改变 。

可以用 None 这个不可变对象来避免这种陷阱：

def add_end(L=None):
    if L is None:
        L = []
        L.append('END')
        return L

自由变量指的是未在 local 作用域中绑定的变量。

局部变量和自由变量的名称保存在__code__属性中：

log("avg.__code__.co_varnames", avg.__code__.co_varnames)
log("avg.__code__.co_freevars", avg.__code__.co_freevars)

=========================== avg.__code__.co_varnames ===========================
('new_value', 'total')
=========================== avg.__code__.co_freevars ===========================
('series',)

自由变量的绑定值保存在__closure__属性中：

log("avg.__closure__", avg.__closure__)

=============================== avg.__closure__ ================================
(<cell at 0x111aff978: list object at 0x111954dc8>,)

__closure__ 中的各个元素对应于 __code__.co_freevars 中的一个名称。 这些元素是 cell 对象，该对象的 cell_contents 属性保存着真正的值：

log("avg.__closure__[0].cell_contents", avg.__closure__[0].cell_contents)

======================= avg.__closure__[0].cell_contents =======================
[10, 11, 12]

def make_averager():
    count = 0
    total = 0

    def averager(new_value):
        count += 1
        total += new_value
        return total / count

    return averager

avg = make_averager()
try:
    print(avg(10))
except Exception as e:
    print(e)

local variable 'count' referenced before assignment

造成上述错误的原因在于，如果 尝试重新绑定 ，例如 count = count + 1 ， 其实会 隐式创建局部变量 count ，从而导致错误。 同时，这样一来， count 就不可能是自由变量了，不会保存在闭包中。

Python 3 引入了 nonlocal 声明，它的作用是 把变量标记为自由变量 ：

def make_averager():
    count = 0
    total = 0

    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count

    return averager

avg = make_averager()
try:
    print(avg(10))
except Exception as e:
    print(e)

10.0

闭包中不要引用任何可能会变化的变量 ：

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

print(f1(), f2(), f3())

9 9 9

如果一定要引用会变化的变量，可以再创建一个函数：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i))
    return fs

f1, f2, f3 = count()
print(f1(), f2(), f3())

1 4 9

import weakref
s = {1, 2, 3}
ender = weakref.finalize(s, lambda: print("Gone with the wind ..."))
print(ender.alive)
del s

True
Gone with the wind ...

弱引用是可调用对象，如果对象存在，调用弱引用可以获取对象，否则返回 None :

import weakref
a = {0, 1}
wref = weakref.ref(a)
print(wref())

{0, 1}

WeakValueDictionary 类实现的是一种可变映射， 里面的值是对象的弱引用 。 被引用的对象在程序中的其他地方被当作垃圾回收后，对应的键会自动从 WeakValueDictionary 中删除。 因此，WeakValueDictionary 经常用于缓存。

import weakref

class Cheese:

    def __init__(self, kind):
        self.kind = kind

stock = weakref.WeakValueDictionary()
catalog = [Cheese('Read Leicester'), Cheese('Tilsit'), Cheese('Brie'), Cheese('Parmesan')]
for cheese in catalog:
    stock[cheese.kind] = cheese

print(sorted(stock.keys()))

del catalog
del cheese
print(sorted(stock.keys()))

['Brie', 'Parmesan', 'Read Leicester', 'Tilsit']
[]

与 WeakValueDictionary 对应的是 WeakKeyDictionary ，后者的键是弱引用。

保存元素弱引用的集合类。元素没有强引用时，集合会把它删除。

如果 一个类需要知道所有实例 ，一种好的方案是创建一个 WeakSet 类型的类属性，用以保存实例的引用。

不是每个 Python 对象都可以作为弱引用的目标 (或称所指对象) 。

list 和 dict 实例不能作为所指对象， 但是它们的子类可以 。

int 和 tuple 实例不能作为弱引用的目标，甚至它们的 子类也不行 。

这些局限是内部优化导致的结果。

为了让对象支持弱引用，必须要有 __weakref__ 这个属性，用户定义的类中默认就有这个属性。

如果类中定义了 __slots__ 属性，而且想把实例作为弱引用的目标， 那么必须把 __weakref__ 添加到 __slots__ 中。

大多数内置抽象基类在 collection.abc, numbers 和 io 模块中定义。

collection.abc 中的抽象基类最常用，其次是 numbers 。

抽象基类中的抽象方法可以有实现代码。

即使实现了， 子类也必须覆盖抽象方法 ，但是在子类中可以使用 super() 函数调用抽象方法。

与其他装饰器一起使用时， @abstractmethod 应放在 最里层 ， 即 @abstractmethod 与 def 之间不能有其他装饰器。

from abc import ABC, abstractmethod

class Pet(ABC):
    @classmethod
    def from_name(cls, name):
        for s_cls in cls.__subclasses__():  # 注意 __subclasses__ 的用法
            if name == s_cls.__name__.lower():
                return s_cls()

    @abstractmethod
    def hello(self):
        pass

class Dog(Pet):

    def hello(self):
        print("WonWonWon")

Pet.from_name("dog").hello()

WonWonWon

虚拟子类的作用在于：即使不通过继承，也可以把一个类注册为抽象基类的子类。

当注册了抽象子类，必须保证所注册的类忠实地实现了抽象基类定义的接口（虽然 Python 并不在注册时做检查）， 否则在运行时可能会抛异常。

注册虚拟子类的方式是在抽象基类上调用 register 方法， register 方法通常作为普通函数调用，也可以作为装饰器使用。

这么做之后，注册的类会变成抽象基类的虚拟子类，而且 issubclass 和 isinstance 都能识别， 但是注册的类不会从抽象基类中继承任何方法或属性 。

@Pet.register
class Cat:
    pass

class Bird(list):
    pass

Pet.register(Bird)

log("issubclass(Cat, Pet)", issubclass(Cat, Pet))
log("isinstance(Bird(), Pet)", isinstance(Bird(), Pet))
log("Bird.__mro__", Bird.__mro__)

==== issubclass(Cat, Pet) ====
True
== isinstance(Bird(), Pet) ===
True
======== Bird.__mro__ ========
(<class '__main__.Bird'>, <class 'list'>, <class 'object'>)

虚拟子类的 __mro__ 属性中没有虚拟基类，说明了虚拟子类并没有从虚拟基类中继承任何方法。

如果把 __dict__ 这个名称添加到 __slots__ 中， 实例会在元祖中保存各个实例的属性，同时还支持动态创建属性，但这样就失去了节省内存的功效。

可以使用 inspect.getgeneratorstate() 获取协程四个状态中的一个：

1. GEN_CREATED：等待开始执行
2. GEN_RUNNING：正在执行（只有在多线程应用中才能看到这个状态）
3. GEN_SUSPENDED：在 yield 表达式处暂停
4. GEN_CLOSED：执行结束

1. 调用 next(my_coro2) ，打印第一个消息，然后执行 yield a ，产出数字 14
2. 调用 my_coro2.send(28) ，把 28 赋值给 b ，打印第二个消息，然后执行 yield a + b ，产出 42
3. 调用 my_coro2.send(99) ，把 99 赋值给 c ，打印第三个消息，协程终止

注意，各个阶段都在 yield 表达式中结束，而且下一个阶段都从那一行代码开始，然后再把 yield 表达式的值赋给变量。

如果不预激，则协程没什么用，即调用 send() 之前，一定要先调用 next() 。

使用 yield from 调用协程时，会 自动预激 。

标准库里的 asyncio.coroutine 装饰器不会预激协程，兼容 yield from 语法。

协程中未处理的异常会向上冒泡，传给调用协程的对象，未处理的异常会导致协程终止。

yield from 主要功能是创建 双向通道 ，将内层生成器直接与外层生成器的 调用方 联系起来。 这样两者可以直接发送和产出值，还可以直接传入异常对象。

即当一个生成器函数需要产出另一个生成器生成的值，可以使用这个语法：

def chain(*iterables):
    for i in iterables:
        yield from i

print(list(chain('ABC', range(3))))

['A', 'B', 'C', 0, 1, 2]

yield from 结构通常会和 asyncio 模块结合起来实现异步编程。

标准库中所有执行阻塞型 I/O 操作的函数，在等待操作系统返回结果时都会释放 GIL 。 这意味着在 Python 语言这个层次上可以使用多线程，I/O 密集型的程序能从中受益。 ( time.sleep() 函数也会释放 GIL)

使用 ProcessPoolExecutor 类把工作分配给多个进程处理可以实现真正的并行运算。

因此，如果需要做 CPU 密集型处理，可以使用它绕开 GIL ，从而利用所有可用的 CPU 。 (多个 Python 进程有各自独立的 GIL 锁，互不影响)

chunksize 只对 ProcessPoolExecutor 有用，用于切分 iterables ，提高运行效率。 因为 future 结果的返回涉及到 IPC ，如果每个进程每次消耗 iterables 中的一个数据，整个过程涉及多个 IPC ，这样效率不高； 但如果对 iterables 进行切分，N 个 数据同时交给一个进程进行处理，运算结果通过一个 IPC 一并返回，这样就可以提升效率。

返回值是一个迭代器，迭代器的__next__方法调用各个 future 对象的 result 方法，得到各个 future 的结果。

from concurrent.futures import ThreadPoolExecutor
import time

def sleep_and_double(value):
    time.sleep(value)
    return value * 2

with ThreadPoolExecutor(max_workers=4) as executor:
    time0 =time.time()
    values = executor.map(sleep_and_double, [3, 2, 1])
    time_delta = time.time() - time0
    print("time consumed0: ", time_delta)
    print(values)
    time0 =time.time()
    print([v for v in values])
    time_delta = time.time() - time0
    print("time consumed1: ", time_delta)

time consumed0:  0.009264230728149414
<generator object Executor.map.<locals>.result_iterator at 0x110912e60>
[6, 4, 2]
time consumed1:  2.9983181953430176

with ThreadPoolExecutor(max_workers=1) as executor:
    time0 = time.time()
    future = executor.submit(sleep_and_double, 3)
    time_delta = time.time() - time0
    print("time consumed0: ", time_delta)
    time0 = time.time()
    print(future.result())
    time_delta = time.time() - time0
    print("time consumed1: ", time_delta)

time consumed0:  0.00031113624572753906
6
time consumed1:  3.004795789718628

如果调用 finished = as_completed(fs, timeout) 后，经过 timeout 时间后仍然无法获取 next(finishes).result() 的值， 则抛出 concurrent.futures.TimeoutError 异常。

from concurrent import futures
fs = []

with ThreadPoolExecutor(max_workers=5) as executor:
    for i in [5, 4, 3, 2, 1]:
        f = executor.submit(sleep_and_double, i)
        fs.append(f)
    time0 = time.time()
    finishes = futures.as_completed(fs)
    time_delta = time.time() - time0
    print("time consumed0: ", time_delta)
    time0 = time.time()
    print([f.result() for f in finishes])
    time_delta = time.time() - time0
    print("time consumed1: ", time_delta)

time consumed0:  2.86102294921875e-06
[2, 4, 6, 8, 10]
time consumed1:  4.999896287918091

fs 可以是一个字典，把各个 future 对象映射到其他有用的数据上， 这样尽管 future 生成的结果顺序可能乱了，依然便于使用结果做后续的处理：

from concurrent import futures
from concurrent.futures import ThreadPoolExecutor
import time
fs = {}

def sleep_and_double(value):
    time.sleep(value)
    return value * 2

with ThreadPoolExecutor(max_workers=5) as executor:
    for i in [5, 4, 3, 2, 1]:
        f = executor.submit(sleep_and_double, i)
        fs[f] = i
    time0 = time.time()
    finishes = futures.as_completed(fs)
    time_delta = time.time() - time0
    print("time consumed0: ", time_delta)
    time0 = time.time()
    for f in finishes:
        print("#{} => {}".format(fs[f], f.result()))
    time_delta = time.time() - time0
    print("time consumed1: ", time_delta)

time consumed0:  7.867813110351562e-06
#1 => 2
#2 => 4
#3 => 6
#4 => 8
#5 => 10
time consumed1:  5.001190900802612

1. 在一个单线程中使用主循环依次激活队列里的协程
2. 各个协程向前执行几步，然后把控制权让给主循环
3. 主循环再激活队列里的下一个协程

编写基于 asyncio 的程序需注意下述细节：

• 编写的协程链始终通过把最外层委派生成器传给 asyncio 包中的某个函数驱动，例如 loop.run_until_complete() 。即我们的代码不通过调用 next() 函数或 send() 方法驱动协程。驱动由 asyncio 包实现的事件循环去做。
• 编写的协程链最终通过 yield from 把职责委托给 asyncio 包中的某个协程函数，如 yeild from asyncio.sleep() ，或者其他库中实现高层协议的协程，如 response = yield from aiohttp.request('GET', url) 。也就是说， 最内层的子生成器是库中真正执行 I/O 操作的函数，而不是我们自己编写的函数。

概括起来就是：使用 asyncio 包时，我们编写的代码中包含委派生成器， 而生成器最终把职责 委托 给 asyncio 包或第三方库中的协程。 这种处理方式相当于 架起了管道 ，让 asyncio 事件循环驱动执行低层异步 I/O 操作的库函数。

交给 asyncio 处理的协程要使用 @asyncio.coroutine 装饰，这虽不是强制要求，但是建议这么做。

因为这样能在一众普通函数中把协程凸显出来，也有助于调试： 如果还没从协程中产出值，协程就被垃圾回收了，可以发出警告。

也可以使用 async 关键字。

asyncio.Future 类的目的是与 yield from 一起使用，通常 不需要 使用以下方法：

• asyncio.Future.add_done_callback()

  因为可以直接把在 Future 运行结束后执行的操作放在 yield from 表达式后面。

• asyncio.Future.result()

  因为 yield from 从 Future 对象中产出的值就是结果。

asyncio.Task 是 asyncio.Future 的子类，与 threading.Thread 地位对等，可以理解为协程中的可调度单元。

使用 C.name 引用类对象 C 的一个属性时，查询操作如下：

1. 当 name 是 C.__dict__ 中的一个键时， C.name 将从 C.__dict__['name'] 中提取值 v。如果 v 是一个描述器，则 C.name 的值就是 type(v).__get__(v, None, C) ，否则，C.name 的值为 v
2. 否则，C.name 将委托查找 C 的基类
3. 否则引发 AttributeError

obj.attr 这样的表达式 不会从 obj 开始寻找 attr ，而是从 obj.__class__ 开始， 仅当类中没有名为 attr 的描述符时，才会在 obj 实例中寻找。

使用 x.name 引用类 C 的实例 x 的一个属性时，查询操作如下：

1. 当 name 作为一个覆盖描述器 v 的名称在类 C （或 C 的某个祖先类）中被找到，x.name 的值就是 type(v).__get__(v, x, C)
2. 否则，当 name 是 x.__dict__ 中的一个键时，返回 x.__dict__['name']
3. 否则，x.name 将委托查找 x 的类，即查找 C.name
4. 如果 C 定义或继承了特殊方法 __getattr__ ，则调用 C.__getattr__(x, 'name') ，而不是引发 AttributeError，然后根据 __getattr__ 返回一个合适的值或者引发 AttributeError

• 使用点号或内置的 getattr, hasattr 和 setattr 函数存取对象属性会触发下述列表中对应的特殊方法
• 直接通过实例的__dict__读写属性不会触发这些特殊方法，通常 使用这种方式跳过特殊方法
• 相比定义这些特殊方法，使用 property 或 descriptor 相对不容易出错

特殊方法使用的警告:

为确保调用特殊方法成功，特殊方法必须定义在类体上，而不能在对象的实例字典中定义。
此外，特殊方法不会被同名实例属性遮盖。

• 若对象__dict__中无同名属性，通过对象实例读取同名描述符实例，返回描述符实例本身
• 若对象__dict__中存在同名属性，通过对象实例读取同名描述符实例，返回对象同名属性 （但特殊方法是特例，解释器 只在实例的类对象中 ，而不是实例对象的__dict__中查找特殊方法）
• 方法就是以这种类型的描述符实现的

• 设置对象同名实例属性时，__set__方法插手接管
• 若对象__dict__中无同名属性，通过对象实例读取同名描述符实例，返回描述符实例本身
• 若对象__dict__中存在同名属性，通过对象实例读取同名描述符实例，返回对象同名属性

def fn(self, name='world'):
    print('Hello, %s.' % name)

Hello = type('Hello', (object,), dict(hello=fn))

h = Hello()
print((type(Hello), type(h)))

(<class 'type'>, <class '__main__.Hello'>)

类的默认元类是父类的元类 ，可以通过关键字 metaclass 指定元类：

class MetaFoo(type):

    def __new__(metacls, name, bases, attrs):
        print("metacls: {}, name: {}, bases: {}, attrs: {}".format(metacls, name, bases, attrs))
        return type.__new__(metacls, name, bases, attrs)

    def __init__(cls, name, bases, attrs): # name, bases, attrs: 与构建类时传给 type 的参数一样
        print("cls: {}, name: {}, bases: {}, attrs: {}".format(cls, name, bases, attrs))

class Foo(str, metaclass=MetaFoo):
    pass

print(dir(Foo))

metacls: <class '__main__.MetaFoo'>, name: Foo, bases: (<class 'str'>,), attrs: {'__module__': '__main__', '__qualname__': 'Foo'}
cls: <class '__main__.Foo'>, name: Foo, bases: (<class 'str'>,), attrs: {'__module__': '__main__', '__qualname__': 'Foo'}
['__add__', '__class__', '__contains__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__module__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

• type 构造方法及元类的__new__和__init__方法都会收到要计算的类的定义体，形式是名称到属性的映射，默认情况下，那个映射所使用的数据结构是字典
• Python3 引入了特殊方法__prepare__，这个特殊方法只在元类中有用，且必须声明为类方法，解释器调用元类的__new__方法前会先调用该方法
• __prepare__方法的第一个参数是元类，随后两个参数分别是要构建的类的名称和基类组成的元组，返回值必须是映射类型
• __prepare__返回的映射对象会传给__new__方法的最后一个参数，然后再传给__init__方法