Python 3 学习笔记

Python

常用网址

• 官方文档
• 深入Python3
• 某Python学习博客
• 廖雪峰Python教程

安装Python

Python Shell

进入交互帮助模式：help()
退出：quit

库的搜索路径：

import sys
sys.path # 返回一个list，第一个是py文件所在的目录 

添加新路径

sys.path.insert(0, '新路径') 

内置数据类型

• Booleans 布尔型：True 或者False。0，空list、tuple、set、dict，None 都为False。
• Numbers 数值型：Integers、Floats、Fractions 分数、Complex Number 复数。
• Strings 字符串：Unicode 字符序列
• Bytes 字节 和 Byte Arrays 字节数组：例如 一份 jpeg 图像文件。用带b前缀的单引号或双引号表示，如b'abc'，每个字符都只占一个字节
• Lists 列表：值的有序序列，变长
• Tuples 元组：值的有序序列，定长
• Sets 集合：装满无序值的包裹。
• Dictionaries 字典：键值对的无序包裹。

常量

Python中，通常用全部大写的变量名表示常量。但是Python根本没有任何机制保证该常量不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法

浮点数

可以用科学计数法，如

a = 1.2e-5

Python的整数没有大小限制
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大

运算符

• / 浮点除法，结果一律float （在Python 2 中表示整数除法）
• // 古怪的整数除法，向下取整，如 11//2为5， -11//2为-6，如果分子或分母中有float，则结果也取整后的float。否则为整数
• ** 幂
• % 余数

分数

import fractions
# 下面定义一个分数 1/3，可以进行常规数学运算
x = fractions.Fraction(1,3)  

会自动进行约分

list

a_list = ['a', 'b', 'mpilgrim', 'z', 'example'] 
# 可以如下调用
a_list[-1] 
# 切片 左闭右开区间
a_list[1:3]
a_list[1:-1]
a_list[0:3] 
a_list[:3]
a_list[3:]
a_list[:]  # 返回元素与a_list相同的新表，复制的捷径
a_list[:3:2] # 前3个元素，每两个取一个
a_list[::2] # 所有数，每2个取一个
# 增加元素
a_list = a_list + [2.0, 3] # 先连接，后赋值
a_list.append(['g', 'h', 'i'])   # 只接受一个参数，可以是任何数据类型。参数会被作为一个list元素放入原来的list中
a_list.extend(['four', 'Ω'])  # 只接受一个list参数，list中每个元素都会分别被添加到list中
a_list.insert(0, 'Ω')  # 指定位置插入
# 删除元素
del a_list[1]
a_list.remove('new')
a_list.pop() # 返回并删除最后一个元素
a_list.pop(1) # 返回并删除指定元素
# 检索值
a_list = ['a', 'b', 'new', 'mpilgrim', 'new']
a_list.count('new')       # 2
'new' in a_list           # True
'c' in a_list             # False
a_list.index('new')       # 2
a_list.index('c')         # 报错

tuple

引用、切片（会创建新tuple）等方法与list相同

a_tuple = ("a", "b", "mpilgrim", "z", "example")  # 也可以用单引号

如果创建单元素元组，需要在值后加一个逗号

好处：

• 元组的速度比列表更快。
• 对不需要改变的数据进行“写保护”将使得代码更加安全。使用元组替代列表就像是有一条隐含的 assert 语句显示该数据是常量，特别的想法（及特别的功能）必须重写。（？？）
• 一些元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。

一次赋多值

# 使用元组，下面的括号都可以省略
v = ('a', 2, True)
(x, y, z) = v 
# 使用迭代器
(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

set

# 创建set
a_set = {1, 2} # 单值set不需要加逗号
a_set = set(a_list)
# 创建空set
a_set = set()
# 创建空字典
a_set = {}  #由于从 Python 2 沿袭而来历史的古怪规定，不能使用两个花括号来创建空集合
# 添加值
a_set.add(4) # 接受单个参数
a_set.update({2, 4, 6})  
a_set.update([10, 20, 30]) 
a_set.update({3, 6, 9}, {1, 2, 3, 5, 8, 13}) 
# 删除值
a_set.discard(10)  # 若元素不存在则什么也不做
a_set.remove(21) # 若元素不存在则报错
a_set.pop() # 随机删除值（set无序），若集合为空则报错
a_set.clear() # 清空set，等价于a_set = set()
# 检测值
30 in a_set 
# 合并set
a_set.union(b_set)   # 返回一个新set
a = a | b # 与上一条等效，下同
# 两个set的交集
a_set.intersection(b_set)   # 返回一个新set
a = a & b
# 剔除set
a_set.difference(b_set)  # 返回a_set中不包含b_set值的新set
a = a - b
# 非交集
a_set.symmetric_difference(b_set)  # 返回仅在其中一个set中出现的值的新set
a = a ^ b
# 对称性， 结果都为true
# 集合是无序的。任何两个包含所有同样值（无一遗漏）的集合可认为是相等的
b_set.symmetric_difference(a_set) == a_set.symmetric_difference(b_set) 
b_set.union(a_set) == a_set.union(b_set) 
b_set.intersection(a_set) == a_set.intersection(b_set) 
# 检测子集
a_set.issubset(b_set) # 前者是否是后者的子集
b_set.issuperset(a_set) # 前者是否是后者的父集

dict

dict是键值对的无序集合。向dict添加一个键的同时，必须为该键增添一个值

# 创建dict
a_dict = {'name': 'allen', 'age': 40}
a_dict = dict()
a_dict = dict(name='allen',age=40)
# 查询
a_dict['server']  # 若key不存在则报错
# 添加值
a_dict['user'] = 'mark'  # 若key已存在则覆盖旧值，key区分大小写
# 迭代
for key in d # 迭代key
for value in d.values() # 迭代value
for k, v in d.items() # 迭代key和value
# 交换key和value
{value:key for key, value in a_dict.items()}

值为list时

SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}
# 长度
len(SUFFIXES) # 2
# 检测值
1000 in SUFFIXES
# 查询值
SUFFIXES[1000] # ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
SUFFIXES[1000][3] # 'TB'

None

None 是 Python 的一个特殊常量。 它是唯一的空值。None 与 False 不同。None 不是 0 。None 不是空字符串。将 None 与任何非 None 的东西进行比较将总是返回 False 。

None 是唯一的空值。它有着自己的数据类型（NoneType）。可将 None 赋值给任何变量，但不能创建其它 NoneType 对象。所有值为 None 变量是相等的。

函数

数据类型转换

int(), float(), bool(), str()

函数别名

把函数名赋给一个变量，相当于给这个函数起了一个“别名”

a = abs
a(-1)

定义函数

def my_abs(x):
    if not isinstance(x, (int, float)): # 数据类型检查
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。
也可以返回多个值：

import math
def move(x, y, step, angle = 0): # angel=0是默认参数，必须写在后
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
# 调用
x, y = move(100, 100, 60, math.pi / 6)
# 也可以缺少angle
x, y = move(100, 100, 60)

实际上是返回一个tuple

如果想定义一个什么事也不做的空函数，可以用pass语句。pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass

def nop():
    pass

pass还可以用在其他语句里，比如：

# 缺少了pass，代码运行就会有语法错误。
if age >= 18:
    pass

参数

默认参数

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
# 调用
enroll('Sarah', 'F')
# 多个默认参数时按位置分配
enroll('Bob', 'M', 7) 
# 也可以指定参数名
enroll('Adam', 'M', city='Tianjin')

注意

def add_end(L=[]): # 默认参数指向[]，[]会变改变
    L.append('END')
    return L

这里的默认参数L也是一个变量，指向对象[]，每次调用该参数，如果改变了L所指向对象的内容，则下次调用时，默认参数的内容就变了。上面函数多次执行add_end()（不传入参数）结果分别为：

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

定义默认参数要牢记一点：默认参数必须指向不变对象！比如None

def add_end(L=None): # 默认参数指向None，None无法被改变
    if L is None:
        L = []
    L.append('END')
    return L

可变参数

允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

# 参数前加*号即可，在函数内部，参数numbers接收到的是一个tuple
def calc(*numbers): 
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
# 调用时可以传入任意个参数
calc()
calc(1)
calc(1,3)
# 把list或tuple的元素变成可变参数，也是加*号
nums = [1, 2, 3]
calc(*nums)

关键字参数

允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

# 两个*号定义
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
# 调用时可以只传入必选参数
person('Michael', 30)
# 也可以传入任意个数的关键字参数
person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')
# 可以先组装出一个dict，然后，把该dict转换为关键字参数传进去
# kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)

命名关键字参数

要限制关键字参数的名字，就可以用命名关键字参数。
命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数

# 可以有默认值
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
# 调用时必须传入参数名，否则将报错。
# 和位置参数一样不能省略
person('Jack', 24, city='Beijing', job='Engineer')

*不是参数，而是特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数

参数组合

可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
#调用
f1(1, 2)
# a = 1 b = 2 c = 0 args = () kw = {}
f1(1, 2, c=3)
# a = 1 b = 2 c = 3 args = () kw = {}
f1(1, 2, 3, 'a', 'b')
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
f1(1, 2, 3, 'a', 'b', x=99)
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
f2(1, 2, d=99, ext=None)
# a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
# 通过一个tuple和dict，也可以调用上述函数
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)
# a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}
f2(*args, **kw)
# a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的

递归函数

尾递归

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出

# 非尾递归
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
# 尾递归：
def fact(n):
    return fact_iter(n, 1)
def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

循环与迭代Iteration

for...in循环

用于迭代

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

对list实现下标循环，enumerate函数可以把一个list变成索引-元素对：

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)

while循环

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

列表生成式

List Comprehensions

# 生成[1x1, 2x2, 3x3, ..., 10x10]
[x * x for x in range(1, 11)]
# 加上判断，筛选出仅偶数的平方
[x * x for x in range(1, 11) if x % 2 == 0]
# 使用两层循环，生成全排列
[m + n for m in 'ABC' for n in 'XYZ']
# 使用多个变量
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]
# 列出当前目录下的所有文件和目录名
import os # 
[d for d in os.listdir('.')] 
# 把一个list中所有的字符串变成小写：
L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]

生成器

Python中，一边循环一边计算的机制，称为生成器generator。
generator保存的是算法，用到时才计算。
列表生成式在生成时已经全部计算好。

第一种定义方法

把一个列表生成式的[]改成()，就创建了一个generator

g = (x * x for x in range(10))
# 通过next()函数计算出generator的下一个值，没有更多的元素时，抛出StopIteration的错误。
next(g)
# 也可以用于迭代，此时不需要next()
for n in g

第二种定义方法

如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator

以斐波拉契数列为例：

# 函数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
# 改成生成器
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
# 一个新的例子
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield 3
    print('step 3')
    yield 5

generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

用for循环调用这种generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中。接上例：

g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器。
可迭代对象Iterable有两类：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator。

# 判断一个对象是不是可迭代对象，用for in循环迭代
from collections import Iterable
isinstance('abc', Iterable) # True
isinstance([1,2,3], Iterable) # True
isinstance(123, Iterable) # False
# 判断一个对象是否是Iterator对象（迭代器，惰性序列），用next()返回下个值
from collections import Iterator
isinstance((x for x in range(10)), Iterator)

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。可以使用iter()函数把它们变成迭代器

iter('abc')

为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

函数式编程

Functional Programming
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言

高阶函数

Higher-order function
变量可以指向函数，函数名就是指向函数的变量。对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

def add(x, y, f):
    return f(x) + f(y)
# 调用
add(-5, 6, abs)

map()和reduce()

Python内建了map()和reduce()函数
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
# r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list
list(r)
# 结果为[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce函数的参数与map类似。它把一个函数作用在一个可迭代对象Iterable上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。效果即：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

# 对一个序列求和，其实可以用sum()函数，这里仅用于说明reduce的用法
from functools import reduce
def add(x, y):
    return x + y
reduce(add, [1, 3, 5, 7, 9]) # 结果为25

map与reduce一起使用，把str转换为int：

from functools import reduce
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))
# 还可以用lambda函数进一步简化成
from functools import reduce
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

filter()

Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

# 只保留奇数
def is_odd(n):
    return n % 2 == 1
result = filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 把一个序列中的空字符串删掉
def not_empty(s):
    return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

eg：欧拉筛法找出素数

# 生成器，从3开始的奇数序列
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n
# 筛选函数
def _not_divisible(n):
    return lambda x: x % n > 0
# 生成器，不断返回下一个素数
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

sorted()

sorted()函数就可以对list进行排序

sorted([36, 5, -12, 9, -21])

sorted()函数也是一个高阶函数：

# 传入key函数来实现自定义的排序
sorted([36, 5, -12, 9, -21], key=abs)
# 传入reverse=True可以反向排序
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回

# 返回求和函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
# 调用
f = lazy_sum(1, 3, 5, 7, 9)
f()
# 每次调用都会返回一个新的函数
f1 = lazy_sum(1, 3, 5, 7, 9)
f2 = lazy_sum(1, 3, 5, 7, 9)
f1==f2 # False

函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

闭包的注意点

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count() # 三个函数执行结果都是9
# 原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

匿名函数

Python对匿名函数提供了有限支持

#计算f(x)=x的平方，直接传入匿名函数：
map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])

关键字lambda表示匿名函数，冒号前面的x表示函数参数
匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，也可以把匿名函数作为返回值返回。

装饰器

本质上，decorator就是一个返回函数的高阶函数。
eg：

# 原函数
def now():
    print('2015-3-25')
# 定义一个装饰器decorator
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# 借助Python的@语法，把decorator置于函数的定义处
# 相当于执行了语句：now = log(now)
@log
def now():
    print('2015-3-25')

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数

# 定义装饰器
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
# 给原函数加上装饰器
# @语句相当于 now = log('execute')(now)，两层括号，第一对括号返回装饰器，第二对括号使用装饰器进行包装
@log('execute')
def now():
    print('2015-3-25')

仍然存在问题
经过decorator装饰之后的函数，它们的name已经从原来的'now'变成了'wrapper'
一个完整的decorator的写法如下：

import functools
# 不带参数
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# 带参数
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

偏函数

偏函数Partial function，和数学意义上的偏函数不一样，用于设定参数的默认值（仍然可以传入其他值）。
创建偏函数：new_func = functools.partial(func,*args,**kw)
eg：

# 转换二进制，自定义函数的方法
def int2(x, base=2):
    return int(x, base)
# 转换二进制，创建偏函数
import functools
int2 = functools.partial(int, base=2)  
# 上述代码实际上固定了int()函数的关键字参数base，相当于：
kw = { 'base': 2 }
int('10010', **kw)
# 如果传入单个值，如
max2 = functools.partial(max, 10)
# 实际上会把10作为*args的一部分自动加到左边，也就是：
max2(5, 6, 7)
# 相当于：
args = (10, 5, 6, 7)
max(*args)

字符串

Python 3，所有的字符串都是使用Unicode编码的字符序列。不再存在以UTF-8或者CP-1252编码的情况。

前缀

以r或R开头(代表raw)的python中的字符串表示（非转义的）原始字符串
以u或U开头的字符串表示unicode字符串
以b或B开头的字符串字节形式表示的字符串bytes

切片

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串

'ABCDEFG'[::2] # 'ACEG'

编码

详见字符串和编码

计算机系统通用的字符编码工作方式：

• 在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
• 用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件
• 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器

为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换

编码与解码单个字符

# 字符转整数编码
ord('A')
# 编码转字符
chr(65)

编码与解码字符串

Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
反之，如果从网络或磁盘上读取了字节流，那么读到的数据就是bytes。

# str转bytes
# python3中，str没有decode方法
'ABC'.encode('ascii') # b'ABC'
'中文'.encode('utf-8') # b'\xe4\xb8\xad\xe6\x96\x87'
# bytes转str
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')

保存Python源代码

Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

字符串长度 len()

# str统计字符个数
len('中国')
# bytes统计字节数
len(b'\xe4\xb8\xad\xe6\x96\x87')

占位符

常见占位符

# 格式化整数和浮点数可以指定是否补0和整数与小数的位数
print('%2d-%02d' % (3, 1)) # '3-01'
print('%.2f' % 3.1415926) # '3.14'
# %s永远起作用，它会把任何数据类型转换为字符串
# 用%%来表示一个%
print('growth rate: %d %%' % 7) # 'growth rate: 7 %'

格式化字符串

文档字符串

文档字符串(docstring)也是字符串。当前的文档字符串占用了多行，所以它使用了相邻的3个引号来标记字符串的起始和终止

  '''Convert a file size to human-readable form.    
    Keyword arguments:
    size -- file size in bytes
    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
                                if False, use multiples of 1000
    Returns: string
    '''  

复合字段名

Python 3支持把值格式化(format)成字符串。可以有非常复杂的表达式，最基本的用法是使用单个占位符(placeholder)将一个值插入字符串。

>>> username = 'mark'
>>> password = 'PapayaWhip' 
>>> "{0}'s password is {1}".format(username, password)
"mark's password is PapayaWhip"

整型替换字段被当做传给format()方法的参数列表的位置索引。即，{0}会被第一个参数替换（在此例中即username），{1}被第二个参数替换（password）

>>> si_suffixes = ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
>>> '1000{0[0]} = 1{0[1]}'.format(si_suffixes)
'1000KB = 1MB'

{0}代表传递给format()方法的第一个参数，即si_suffixes。注意si_suffixes是一个列表。所以{0[0]}指代si_suffixes的第一个元素，即'KB'。同时，{0[1]}指代该列表的第二个元素，即：'MB'。大括号以外的内容 — 包括1000，等号，还有空格等 — 则按原样输出。语句最后返回字符串为'1000KB = 1MB'。

这个例子说明格式说明符可以通过利用（类似）Python的语法访问到对象的元素或属性。这就叫做复合字段名(compound field names)。以下复合字段名都是“有效的”。

• 使用列表作为参数，并且通过下标索引来访问其元素（跟上一例类似）
• 使用字典作为参数，并且通过键来访问其值
• 使用模块作为参数，并且通过名字来访问其变量及函数
• 使用类的实例作为参数，并且通过名字来访问其方法和属性

以上方法的任意组合

为了使你确信的确如此，下面这个样例就组合使用了上面所有方法：

>>> import humansize
>>> import sys
>>> '1MB = 1000{0.modules[humansize].SUFFIXES[1000][0]}'.format(sys)
'1MB = 1000KB'

下面是描述它如何工作的：

sys模块保存了当前正在运行的Python实例的信息。由于已经导入了这个模块，因此可以将其作为format()方法的参数。所以替换域{0}指代sys模块。

sys.modules是一个保存当前Python实例中所有已经导入模块的字典。模块的名字作为字典的键；模块自身则是键所对应的值。所以{0.modules}指代保存当前己被导入模块的字典。

替换域{0.modules[humansize]}指代humansize模块。

请注意以上两句在语法上轻微的不同。在实际的Python代码中，字典sys.modules的键是字符串类型的；为了引用它们，我们需要在模块名周围放上引号（比如 'humansize'）。但是在使用替换域的时候，我们在省略了字典的键名周围的引号（比如 humansize）。在此，我们引用PEP 3101：字符串格式化高级用法，“解析键名的规则非常简单。如果名字以数字开头，则它被当作数字使用，其他情况则被认为是字符串。”

sys.modules['humansize'].SUFFIXES是在humansize模块的开头定义的一个字典对象。{0.modules[humansize].SUFFIXES}即指向该字典。

sys.modules['humansize'].SUFFIXES[1000]是一个si（国际单位制）后缀列表：['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']。所以替换域{0.modules[humansize].SUFFIXES[1000]}指向该列表。

sys.modules['humansize'].SUFFIXES[1000][0]即si后缀列表的第一个元素：'KB'。因此，整个替换域{0.modules[humansize].SUFFIXES[1000][0]}最后都被两个字符KB替换。

格式说明符

if size < multiple:
    return '{0:.1f} {1}'.format(size, suffix)

{0:.1f}中的:.1f则不一定了。第二部分（包括冒号及其后边的部分）即格式说明符(format specifier)，它进一步定义了被替换的变量应该如何被格式化。

☞格式说明符的允许你使用各种各种实用的方法来修饰被替换的文本，就像C语言中的printf()函数一样。我们可以添加使用零填充(zero-padding)，衬距(space-padding)，对齐字符串(align strings)，控制10进制数输出精度，甚至将数字转换成16进制数输出。

在替换域中，冒号(:)标示格式说明符的开始。“.1”的意思是四舍五入到保留一们小数点。“f”的意思是定点数（与指数标记法或者其他10进制数表示方法相对应）。因此，如果给定size为698.24，suffix为'GB'，那么格式化后的字符串将是'698.2 GB'，因为698.24被四舍五入到一位小数表示，然后后缀'GB'再被追加到这个串最后。

>>> '{0:.1f} {1}'.format(698.24, 'GB')
'698.2 GB'

模块与包

模块（Module）：一个.py文件
包（package）：一个目录
相同名字的函数和变量完全可以分别存在不同的模块中，但是尽量不要与内置函数名字冲突。
Python的所有内置函数

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码。无论一个包的哪个部分被导入,

import os
系统在导入模块时，要做以下三件事：
1.为源代码文件中定义的对象创建一个名字空间，通过这个名字空间可以访问到模块中定义的函数及变量。
2.在新创建的名字空间里执行源代码文件.
3.创建一个名为源代码文件的对象，该对象引用模块的名字空间，这样就可以通过这个对象访问模块中的函数及变量

import os as system
模块导入时可以使用 as 关键字来改变模块的引用对象名字。

from socket import gethostname
使用from语句可以将模块中的对象直接导入到当前的名字空间。 from语句不创建一个到模块名字空间的引用对象，而是把被导入模块的一个或多个对象直接放入当前的名字空间。可以使用星号*代表模块中除下划线开头的所有对象。不过，如果一个模块如果定义有列表__all__，则from module import * 语句只能导入__all__列表中存在的对象。

import 语句可以在程序的任何位置使用，你可以在程序中多次导入同一个模块，但模块中的代码仅仅在该模块被首次导入时执行。后面的import语句只是简单的创建一个到模块名字空间的引用而已。sys.modules字典中保存着所有被导入模块的模块名到模块对象的映射。这个字典用来决定是否需要使用import语句来导入一个模块的最新拷贝。
from module import * 语句只能用于一个模块的最顶层。特别注意：由于存在作用域冲突，不允许在函数中使用from 语句。

每个模块都拥有__name__属性，它是一个内容为模块名字的字符串。最顶层的模块名称是__main__。命令行或是交互模式下程序都运行在__main__模块内部。利用__name__属性，我们可以让同一个程序在不同的场合（单独执行或被导入)具有不同的行为，象下面这样做：

# 检查是单独执行还是被导入
if __name__ == '__main__':
      # Yes
      statements
else:
      # No (可能被作为模块导入)
      statements 

可以被 import 语句导入的模块共有以下四类:

• 使用Python写的程序( .py文件)
• C或C++扩展(已编译为共享库或DLL文件)
• 包(包含多个模块)
• 内建模块(使用C编写并已链接到Python解释器内)

当查询模块 foo 时,解释器按照 sys.path 列表中目录顺序来查找以下文件(目录也是文件的一种):
1.定义为一个包的目录 foo
2.foo.so, foomodule.so, foomodule.sl,或 foomodule.dll (已编译扩展)
3.foo.pyo (只在使用 -O 或 -OO 选项时)
4.foo.pyc
5.foo.py

对于.py文件，当一个模块第一次被导入时，它就被汇编为字节代码，并将字节码写入一个同名的.pyc文件。后来的导入操作会直接读取.pyc文件而不是.py文件。(除非.py文件的修改日期更新，这种情况会重新生成.pyc文件) 在解释器使用 -O 选项时，扩展名为.pyo的同名文件被使用。pyo文件的内容去掉行号、断言、及其他调试信息的字节码，体积更小，运行速度更快。如果使用-OO选项代替-O，则文档字符串也会在创建.pyo文件时也被忽略。

如果在sys.path提供的所有路径均查找失败，解释器会继续在内建模块中寻找，如果再次失败，则引发 ImportError 异常。

.pyc和.pyo文件的汇编，当且仅当import 语句执行时进行。

当 import 语句搜索文件时，文件名是大小写敏感的。即使在文件系统大小写不敏感的系统上也是如此(Windows等)。

reload(sys)
如果更新了一个已经用import语句导入的模块，内建函数reload()可以重新导入并运行更新后的模块代码。在reload()运行之后的针对模块的操作都会使用新导入代码，不过reload()并不会更新使用旧模块创建的对象，因此有可能出现新旧版本对象共存的情况。
注意 使用C或C++编译的模块不能通过 reload() 函数来重新导入。记住一个原则，除非是在调试和开发过程中，否则不要使用reload()函数。

无论一个包的哪个部分被导入，在文件__init__.py中的代码都会运行。导入过程遇到的所有 __init__.py文件都被运行。

from Graphics.Primitive import *
这个语句的原意图是想将Graphics.Primitive包下的所有模块导入到当前的名称空间。然而，由于不同平台间文件名规则不同(比如大小写敏感问题), Python不能正确判定哪些模块要被导入。这个语句只会顺序运行 Graphics 和 Primitive 文件夹下的__init__.py文件。__init__.py中定义一个名字all的列表。
这和导入模块不同，类似语句可以正常导入模块下的所有函数。

下面这个语句只会执行Graphics目录下的__init__.py文件，而不会导入任何模块: import Graphics。不过既然 import Graphics 语句会运行 Graphics 目录下的 __init__.py文件，只需要在其中把所有模块都import进去就行了。

sys.modules包含了当前所load的所有的modules的dict（其中包含了builtin的modules）

Python模块的标准文件模板：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释 '
__author__ = '作者名'

通过_前缀定义作用域：

• 正常的函数和变量名是公开的（public），可以被直接引用。
• __xxx__：特殊变量，可以被直接引用，但是有特殊用途。模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名
• _xxx和__xxx：非公开（private），只是一个命名习惯，外部仍然可以访问

Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。

安装第三方模块

安装Python时确保勾选pip和Add python.exe to Path。
一般来说，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索。

以安装Python Imaging Library为例，这是Python下非常强大的处理图像的工具库。
运行命令：pip install Pillow即可。
简单用法：

from PIL import Image
im = Image.open("d:\\backup\\140591\\桌面\\首页图片\\11.jpg")
print(im.format, im.size, im.mode)
im.thumbnail((200, 100)) # 缩小图片
im.save('22.jpg', 'JPEG') # 保存

其他常用的第三方库还有MySQL的驱动：mysql-connector-python，用于科学计算的NumPy库：numpy，用于生成文本的模板工具Jinja2，等等。

当我们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件。默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中。

要添加自己的搜索目录，有两种方法：

1. 直接修改sys.path，添加要搜索的目录：sys.path.append('/Users/michael/my_py_scripts')。这种方法是在运行时修改，运行结束后失效。
2. 设置环境变量PYTHONPATH。

sys

sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称。
运行python3 hello.py获得的sys.argv就是['hello.py']。
在命令行直接运行一个模块文件时，Python解释器把一个特殊变量__name__置为`__main__`，注意带了引号。如果是import一个模块，则此变量值为模块文件名，不带路径或扩展名。

面向对象编程

Object Oriented Programming，简称OOP。

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

# 定义
class Student(object):
    # 限制该class实例在运行期间能添加的属性，可选。对子类无效
    __slots__ = ('name', 'age') 
    # 此处定义类属性
    count = 0
    # __init__方法的第一个参数永远是self，表示创建的实例本身
    # 此处定义实例属性
    def __init__(self, name, score): 
        self.name = name
        self.score = score
    # 使此class可以适用于系统的len()函数，len('king')，len(obj)...可选
    def __len__(self):
        # 自己实现
    # 类似Java的toString方法，打印对象时调用。可选。
    # 返回用户看到的字符串
    def __str__(self):
        return 'Student object (name: %s)' % self.name
    # 在解释器中直接输变量，会调用此__repr__()方法。可选
    # 返回程序开发者看到的字符串，此处是偷懒的写法，使两者一样。
    __repr__ = __str__
    # 使此类的对象可以被用于for ... in循环。可选
    # 返回一个迭代对象，该迭代对象必须实现__next__()方法，迭代结束时raise StopIteration()
    def __iter__(self):
        # 自定义实现
    # 使此类的对象可以像list那样按照下标取出元素，可选。
    # 如果把对象看成dict，__getitem__()的参数也可能是一个可以作key的object，此处未实现
    # 与此对应的是__setitem__()方法，把对象视作list或dict来对集合赋值；__delitem__()方法，删除某个元素
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            # 取出对象...
        if isinstance(n, slice): # n是切片，slice表示切片对象
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            # 取出list...注意要对负数、步长参数作处理
    # 调用的属性或方法在类中不存在时，会在此处找，可选。
    # 默认返回None
    def __getattr__(self, attr):
        if attr=='sex':
            return 'man' # 返回属性
        if attr=='hisage': # 仅作示范，不用在意名字
            return lambda: 25 # 返回函数
        raise AttributeError('自定义错误信息') # 抛出Error，不再返回默认的None
    # 直接把实例当成方法用，可选。
    # 一般用instance.method()的形式调用方法，但是定义了此方法后，可以用instance()，如：Student('Michael')()。
    # 可添加参数
    def __call__(self):
        print('My name is %s.' % self.name)
    # 其他方法也和__init__类似  
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))
    # @property装饰器把一个getter方法变成属性
    # 此处@property又创建了另一个装饰器@score.setter
    @property
    def score(self):
        return self._score
    # 如果不设置此set方法，则为只读属性
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
#################---使用----#############    
# 创建实例
s = Student('Bart Simpson', 59)
# score属性的set与get
s.score = 60 # 实际转化为s.set_score(60)
s.score # 实际转化为s.get_score()
# 绑定属性。对象名改成Class名即可对Class绑定
s.age = 8 # 注意class中并没有定义age变量
# 删除属性
del s.name
# 绑定方法，注意区别。对象名改成Class名即可对Class绑定
# 第一种方法：
def nono():
    print('nono')
s.nono = nono 
s.nono()
# 第二种方法：
def nono(self):
    print('nono')
from types import MethodType
s.nono = MethodType(nono, bart)
s.nono()
# 例外：slots只能限制添加属性，不能限制通过添加方法来添加属性：
# 绑定下面的方法即可绕过slots限制
def set_city(self, city):
    self.city=city

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
有了__init__方法，在创建实例的时候，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。

重点提一下__getattr__动态调用的用法。例如很多网站都搞REST API，比如新浪微博、豆瓣啥的，调用API的URL类似http://api.server/user/timeline/list。如果要写SDK，给每个URL对应的API都写一个方法，那得累死，而且，API一旦改动，SDK也要改。利用完全动态的__getattr__，我们可以写出一个链式调用：

# 定义
class Chain(object):
    def __init__(self, path=''):
        self._path = path
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def __str__(self):
        return self._path
    __repr__ = __str__
# 调用
Chain().status.user.timeline.list
# 结果为：'/status/user/timeline/list'

__call__()使得我们对实例进行直接调用就好比对一个函数进行调用一样，这么一来，我们就模糊了对象和函数的界限。能被调用的对象（也就是可以当成一个函数使用）就是一个Callable对象:

callable(Student()) # 对于类来说，必须实现__call__()才能当函数用
callable(max) # True
callable([1, 2, 3]) # False
callable(None) # False
callable('str') # False
callable(str) # True

访问控制

实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。例外：__xxx__是特殊变量，特殊变量是可以直接访问的，不是private变量。

一个下划线开头的实例变量名_xxx，外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__xxx是因为Python解释器对外把__xxx变量改成了_类名__xxx，所以，仍然可以通过_类名__xxx来访问该变量。不同版本的Python解释器可能会把__name改成不同的变量名。

继承和多态

多态的好处：调用方只管调用，不管细节。这就是著名的开闭原则：对扩展开放，对修改封闭。

静态语言 vs 动态语言

举例说明：

def run_twice(animal):
    animal.run()

对于静态语言（例如Java）来说，上述代码传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了。

获取对象信息

# 对象类型，使用type()返回对应的Class类型
type(123) # <class 'int'>
type(None) # <type(None) 'NoneType'>
type(abs) # <class 'builtin_function_or_method'>
type(123)==int # True
# 判断一个对象是否是函数，使用types模块的常量
import types
def fn():
    pass
type(fn)==types.FunctionType
type(abs)==types.BuiltinFunctionType
type(lambda x: x)==types.LambdaType
type((x for x in range(10)))==types.GeneratorType
# 判断class的类型，使用isinstance()函数
isinstance(h, Dog)
# 能用type()判断的基本类型也可以用isinstance()判断
isinstance(123, int) # True
isinstance(b'a', bytes) # True
# 可以判断是否某些类型中的一种
isinstance([1, 2, 3], (list, tuple)) # True
# 获得一个对象的所有属性和方法，使用dir()函数返回一个包含字符串的list
dir('ABC')
# 操作一个对象的状态，getattr()、setattr()以及hasattr()
hasattr(obj, 'y') # 有属性或方法'y'吗？
setattr(obj, 'y', 19) # 设置一个属性'y'
getattr(obj, 'y') # 获取属性'y'

Python中，如果调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法。自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法

要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。如：

def readImage(fp):
    if hasattr(fp, 'read'):
        return readData(fp)
    return None

上述代码从文件流fp中读取图像，首先要判断该fp对象是否存在read方法，如果存在，则该对象是一个流，如果不存在，则无法读取。

多重继承

在设计类的继承关系时，通常，主线都是单一继承下来的。但是，如果需要“混入”额外的功能，通过多重继承就可以实现。这种设计通常称之为MixIn。
eg：
Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixIn和ThreadingMixIn提供。通过组合，我们就可以创造出合适的服务来。

# 编写一个多进程模式的TCP服务
class MyTCPServer(TCPServer, ForkingMixIn):
    pass
# 编写一个多线程模式的UDP服务
class MyUDPServer(UDPServer, ThreadingMixIn):
    pass
# 如果你打算搞一个更先进的协程模型，可以编写一个CoroutineMixIn：
class MyTCPServer(TCPServer, CoroutineMixIn):
    pass

这样一来，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。

枚举类

# 定义方法一
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
# 引用
Month.Jan
# 枚举
# value属性是自动赋给成员的int常量，默认从1开始计数
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
'''输出如下：
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12
'''
# 定义方法二：
# @unique装饰器可以帮助我们检查保证没有重复值
from enum import Enum, unique
@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
# 访问这些枚举类型的若干种方法：
day1 = Weekday.Mon
Weekday.Tue
Weekday['Tue']　# Weekday.Tue
Weekday.Tue.value # 2
Weekday(1) # Weekday.Mon
Weekday(7) # 抛出ValueError: 7 is not a valid Weekday
for name, member in Weekday.__members__.items():
    print(name, '=>', member)
'''
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat
'''

元类

#### type()查看类或变量的类型
class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)
type(Hello) # 输出<class 'type'>，表示这个class的类型是type
#### type()创建class
def fn(self, name='world'): # 先定义函数
    print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
# type(类名, 父类的元组（针对继承的情况，可以为空），包含属性、方法的字典（名称和值）)
MyShinyClass = type('MyShinyClass', (), {})
Foo = type('Foo', (), {'bar':True}) # 注意这个bar是类属性
FooChild = type('FooChild', (Foo,),{}) 
# 也可以增加方法
def echo_bar(self): 
    print self.bar
FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) 

str类用来创建字符串对象
int类用来创建整数对象
type类用来创建类对象

Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
除此之外还可以用metaclass动态创建类。
eg，给自定义的MyList添加add方法：

# metaclass是类的模板，所以必须从`type`类型派生：
class ListMetaclass(type): # 默认习惯，metaclass的类名总是以Metaclass结尾
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)
# 使用ListMetaclass来定制类
class MyList(list, metaclass=ListMetaclass): # 传入关键字参数metaclass
    pass
# Python解释器在创建MyList时，找到metaclass关键字就会通过元类的__new__()来创建类。
# __new__()的参数：新类的对象、新类的名字、新类继承的父类集合、新类的属性方法集合

创建类的过程：
1. 当前类中寻找__metaclass__属性
2. 在父类中寻找该属性
3. 模块层次中寻找该属性
4. 用内置的type来创建这个类对象。
前三步中只要找到就用它创建类。

模块中添加__metaclass__：

'''模块中添加__metaclass__'''
# 元类会自动将你通常传给'type'的参数作为自己的参数传入 
def upper_attr(future_class_name, future_class_parents, future_class_attr): 
    '''返回一个类对象，将属性都转为大写形式'''
    #  选择所有不以'__'开头的属性 
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
     # 将它们转为大写形式 
    uppercase_attr = dict((name.upper(), value) for name, value in attrs) 
    # 通过'type'来做类对象的创建 
    return type(future_class_name, future_class_parents, uppercase_attr) 
'''注意这条语句的位置，它属于整个模块'''
__metaclass__ = upper_attr  #  这会作用到这个模块中的所有类 
class Foo(object): 
    # 我们也可以只在这里定义__metaclass__，这样就只会作用于这个类中 
    bar = 'bip'
hasattr(Foo, 'bar') # 输出: False 
hasattr(Foo, 'BAR') # 输出:True 

类定义中添加__metaclass__：

# 沿用上面的代码
# 必须传入type或子类
class UpperAttrMetaClass(type): 
    # __new__ 是在__init__之前被调用的特殊方法 
    # __new__是用来创建对象并返回之的方法 
    # 而__init__只是用来将传入的参数初始化给对象 
    # 你很少用到__new__，除非你希望能够控制对象的创建 
    # 这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__ 
    # 如果你希望的话，你也可以在__init__中做些事情 
    # 还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用 
    def __new__(cls, name, bases, dct): 
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__') 
        uppercase_attr  = dict((name.upper(), value) for name, value in attrs) 
    # 复用type.__new__方法 
    return type.__new__(cls, name, bases, uppercase_attr)
    # 最后一句也可以使用super
    return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)

metaclass修改类定义的典型的例子：ORM，全称Object Relational Mapping，即对象-关系映射。就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。

# 定义一个User类来操作对应的数据库表User
class User(Model):
    # 定义类的属性到列的映射：
    # 父类Model和属性类型StringField、IntegerField是由ORM框架提供的
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')
# 创建一个实例：
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
# 保存到数据库：
u.save()
# 输出如下：
'''
Found model: User
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:uid>
Found mapping: name ==> <StringField:username>
SQL: insert into User (password,email,username,id) values (?,?,?,?)
ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]
'''
'''-----------上面是此ORM框架的使用，下面是定义-----------'''
# Field类负责保存数据库表的字段名和字段类型
class Field(object):
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type
    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)
# 在Field的基础上，进一步定义各种类型的Field
class StringField(Field):
    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')
class IntegerField(Field):
    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')
# 编写ModelMetaclass
class ModelMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 先排除对Model类对象的修改，则此元类只会影响User类对象的创建
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        # 显示正在修改的类，调试用
        print('Found model: %s' % name) 
        # 用于存储Field属性映射
        mappings = dict()
        # 遍历类的所有属性，把所有Field属性保存到mappings中
        # 字典attrs中保存属性名称和属性值的映射，如id与IntegerField('id')。
        for k, v in attrs.items():
            if isinstance(v, Field):
                # 调试用的输出语句
                print('Found mapping: %s ==> %s' % (k, v))
                # 存储符合条件的Filed属性
                mappings[k] = v
        # 从类属性中删除该Field属性
        for k in mappings.keys():
            attrs.pop(k)
        # 保存属性和列的映射关系
        attrs['__mappings__'] = mappings 
        # 把表名保存到__table__中，假设表名和类名一致
        attrs['__table__'] = name 
        return type.__new__(cls, name, bases, attrs)
# 基类Model，可以定义各种操作数据库的方法，比如save()，delete()，find()，update()等等
class Model(dict, metaclass=ModelMetaclass):
    def __init__(self, **kw):
        super(Model, self).__init__(**kw)
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)
    def __setattr__(self, key, value):
        self[key] = value
    def save(self):
        # 变量名
        fields = []
        # 参数
        params = []
        # 变量值
        args = []
        for k, v in self.__mappings__.items():
            # 这里的v是指字典中的value，阅读前面的代码可知是个Field的子类的实例
            # 该实例一个名为name的属性，创建对象时传入
            # 如StringField('username')，此处`username`即是name属性
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))
        # 'xxx'.join(alist)用xxx为分隔符把列表alist连接成字符串
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))