Python 3 学习笔记2

教程连接：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

高级特性

切片

取一个list或tuple的部分元素是很是常见的操做。好比，一个list以下：

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

取前3个元素，应该怎么作？

笨办法：

>>> [L[0], L[1], L[2]]
['Michael', 'Sarah', 'Tracy']

之因此是笨办法是由于扩展一下，取前N个元素就没辙了。

取前N个元素，也就是索引为0-(N-1)的元素，能够用循环：

>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
... 
>>> r
['Michael', 'Sarah', 'Tracy']

对这种常常取指定索引范围的操做，用循环十分繁琐，所以，Python提供了切片（Slice）操做符，能大大简化这种操做。

对应上面的问题，取前3个元素，用一行代码就能够完成切片：

>>> L[0:3]
['Michael', 'Sarah', 'Tracy']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

若是第一个索引是0，还能够省略：

>>> L[:3]
['Michael', 'Sarah', 'Tracy']

也能够从索引1开始，取出2个元素出来：

>>> L[1:3]
['Sarah', 'Tracy']

相似的，既然Python支持L[-1]取倒数第一个元素，那么它一样支持倒数切片，试试：

>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

记住倒数第一个元素的索引是-1。

切片操做十分有用。咱们先建立一个0-99的数列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

能够经过切片轻松取出某一段数列。好比前10个数：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20个数：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10个数，每两个取一个：

>>> L[:10:2]
[0, 2, 4, 6, 8]

全部数，每5个取一个：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就能够原样复制一个list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一种list，惟一区别是tuple不可变。所以，tuple也能够用切片操做，只是操做的结果还是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也能够当作是一种list，每一个元素就是一个字符。所以，字符串也能够用切片操做，只是操做结果还是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在不少编程语言中，针对字符串提供了不少各类截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只须要切片一个操做就能够完成，很是简单。

小结

有了切片操做，不少地方循环就再也不须要了。Python的切片很是灵活，一行代码就能够实现不少行循环才能完成的操做。

L=list(range(10))
# L中的元素是0-9
一、L[n1:n2:n3]
n1表明开始元素下标
n2表明结束元素下标
n3表明切片间隔以及切片方向
L中每一个元素都有正负两种下标，例如L[0]和L[-10]指的同一个元素都是0
二、L[::1]与L[::-1]
在L[::1]中n1是0(-10)，n2是9(-1)
在L[::-1]中n1是9(-1),n2是0(-10)
三、L[-1:1]是多少？
答案是[]，由于L[-1:1]的彻底表示方式是L[-1:1:1],翻译出来就是
：从下标为-1的元素开始，以正方向切片到下标为1的元素。可是python从下标为-1的元素以正方向切片到列表结束也没有发现下标为1的元素，那么L[-1:1]的计算结果就是[].
四、L[-1:1:-1]是多少？
答案是[9, 8, 7, 6, 5, 4, 3, 2]，python将这个表达式解释为：
从下标为-1的元素开始，以反方向切片到下标为1的元素。那么ok，python能够找到这一段子序列，结果就是[9, 8, 7, 6, 5, 4, 3, 2]

例子：

L = [1,2,3,4,5,6,7,8,9]
print(L[::1])#------>[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(L[:8:1])#----->[1, 2, 3, 4, 5, 6, 7, 8]
print(L[:9:1])#----->[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(L[:15:1])#---->[1, 2, 3, 4, 5, 6, 7, 8, 9] ,即便超出游标也不影响
print(L[-2::1])#---->[8, 9]
print(L[-2::-1])#--->[8, 7, 6, 5, 4, 3, 2, 1]
print(L[-2:0:-1])#-->[8, 7, 6, 5, 4, 3, 2] 
print(L[-2:0:-2])#-->[8, 6, 4, 2]
print(L[-2:4:-2])#-->[8, 6]
print(L[-2:4:-1])#-->[8, 7, 6]
print(L[-2:4])#----->[]

说明：

1.sequence[a:b]输出下标a到b-1的序列

（例子：L = [1,2,3,4,5,6,7,8,9]

L[0:9]#-->[1, 2, 3, 4, 5, 6, 7, 8, 9]

L[1:9]#-->[2, 3, 4, 5, 6, 7, 8, 9]

若是是倒序，例如：[-2:0:-1]，是从倒数第2（没有-0位）个开始

L[-2:0:-1]#-->[8, 7, 6, 5, 4, 3, 2] ）

2.sequence[:b]输出从开使下标0到b-1的序列

3.sequence[::-1]翻转操做.

4.sequence[::2]隔一个取一个

注:sequence的下标: 从0  1  2  3......(n-3)  (n-2)  (n-1)

                                对应:(-n)  -(n-1)  -(n-2)  ......... -3  -2  -1

迭代

若是给定一个list或tuple，咱们能够经过for循环来遍历这个list或tuple，这种遍历咱们称为迭代（Iteration）。

在Python中，迭代是经过for ... in来完成的，而不少语言好比C或者Java，迭代list是经过下标完成的，好比Java代码：

for (i=0; i<list.length; i++) {
    n = list[i];
}

能够看出，Python的for循环抽象程度要高于Java的for循环，由于Python的for循环不只能够用在list或tuple上，还能够做用在其余可迭代对象上。

list这种数据类型虽然有下标，但不少其余数据类型是没有下标的，可是，只要是可迭代对象，不管有无下标，均可以迭代，好比dict就能够迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

由于dict的存储不是按照list的方式顺序排列，因此，迭代出的结果顺序极可能不同。

默认状况下，dict迭代的是key。若是要迭代value，能够用for value in d.values()，若是要同时迭代key和value，能够用for k, v in d.items()。

因为字符串也是可迭代对象，所以，也能够做用于for循环：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

因此，当咱们使用for循环时，只要做用于一个可迭代对象，for循环就能够正常运行，而咱们不太关心该对象到底是list仍是其余数据类型。

那么，如何判断一个对象是可迭代对象呢？方法是经过collections模块的Iterable类型判断：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

最后一个小问题，若是要对list实现相似Java那样的下标循环怎么办？Python内置的enumerate函数能够把一个list变成索引-元素对，这样就能够在for循环中同时迭代索引和元素自己：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循环里，同时引用了两个变量，在Python里是很常见的，好比下面的代码：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

小结

任何可迭代对象均可以做用于for循环，包括咱们自定义的数据类型，只要符合迭代条件，就可使用for循环。

列表生成式

列表生成式即List Comprehensions，是Python内置的很是简单却强大的能够用来建立list的生成式。

举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]能够用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但若是要生成[1x1, 2x2, 3x3, ..., 10x10]怎么作？方法一是循环：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

可是循环太繁琐，而列表生成式则能够用一行语句代替循环生成上面的list：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就能够把list建立出来，十分有用，多写几回，很快就能够熟悉这种语法。

for循环后面还能够加上if判断，这样咱们就能够筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可使用两层循环，能够生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

三层和三层以上的循环就不多用到了。

运用列表生成式，能够写出很是简洁的代码。例如，列出当前目录下的全部文件和目录名，能够经过一行代码实现：

>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir能够列出文件和目录
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode']

for循环其实能够同时使用两个甚至多个变量，好比dict的items()能够同时迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

所以，列表生成式也可使用两个变量来生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

最后把一个list中全部的字符串变成小写：

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

练习

若是list中既包含字符串，又包含整数，因为非字符串类型没有lower()方法，因此列表生成式会报错：

>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
AttributeError: 'int' object has no attribute 'lower'

使用内建的isinstance函数能够判断一个变量是否是字符串：

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

纯输出小写字符串答案：

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1 if isinstance(x,str)]
print(L2)

混合输出小写字符串（非字符串也输出）答案：

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() if isinstance(x,str) else x for x in L1]
print(L2)

上面使用了三目运算符：

true_part if condition else false_part

http://wangye.org/blog/archives/690/

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？

若是要一个一个打印出来，能够经过next()函数得到generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

咱们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

固然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

因此，咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误。

generator很是强大。若是推算的算法比较复杂，用相似列表生成式的for循环没法实现的时候，还能够用函数来实现。

好比，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，赋值语句：

a, b = b, a + b

至关于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

但没必要显式写出临时变量t就能够赋值。

上面的函数能够输出斐波那契数列的前N个数：

>>> fib(6)
1
1
2
3
5
8
'done'

仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print(b)改成yield b就能够了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

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

举个简单的例子，定义一个generator，依次返回数字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

调用该generator时，首先要生成一个generator对象，而后用next()函数不断得到下一个返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

能够看到，odd不是普通函数，而是generator，在执行过程当中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield能够执行了，因此，第4次调用next(o)就报错。

回到fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。

一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

可是用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
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

关于如何捕获错误，后面的错误处理还会详细讲解。

练习

杨辉三角定义以下：

          1
        1   1
      1   2   1
    1   3   3   1
  1   4   6   4   1
1   5   10  10  5   1

把每一行看作一个list，试写一个generator，不断输出下一行的list：

答案：

def triangles():
    L = [1]
    while True:
        yield L
        L.append(0)
        L = [L[i - 1] + L[i] for i in range(len(L))]


n = 0
for t in triangles():
    print(t)
    n = n + 1
    if n == 10:
        break

 解析：

杨辉三角/帕斯卡三角形

        1
       1 1
      1 2 1
     1 3 3 1
    1 4 6 4 1
   . . . . . .

虽然看着挺漂亮，但对解题没有卵帮助。 因而我从右边猛推了它一把 <---大力猛推。 伴随着一声'啊呦'，杨辉三角形一屁股坐进了我精心设计好的墙角里。

row
0    1
1    1 1
2    1 2 1
3    1 3 3 1
4    1 4 6 4 1
------------------
col  0 1 2 3 4

据说，下雨天，笛卡尔坐标系(码农版)和帕斯卡三角形更配哦~ 【某芙广告部请联络我，洽谈代言事宜！】

这不是巧了么？我能够用T(row,col)来表明杨辉三角形中的每个元素对不对？ 而后你们能够发现以下几个事实: 1.col==0 的这一列上的元素老是 1 ， 例如T(0,0),T(1,0),T(4,0) 2.col==row 的这一列上的元素老是 1, 例如 T(0,0),T(1,1),T(4,4) 3.(敲黑板,重点) T(row,col)上的元素等于 T(row-1,col-1)+T(row-1,col)， 例如 T(4,3) == T(3,2)+T(3,3) 即 4 == 3 + 1 例如 T(4,2) == T(3,1)+T(3,2) 即 6 == 3 + 3 虽然讲得颇有道理的样子，然而机智的小伙伴们仍是一眼就看出了破绽。 介绍事实3时候，为何不拿T(0,0),T(1,0)，T(1,1)这样的元素举例？ 按个人分析 T(0,0) == T(-1,-1)+T(-1,0) ,这不翻车了么。妈蛋的，确实翻车了！

def triangles():
    L = [1] #因此在这个解法里，做者很机智，直接给第0行初始化一个[1]
    while True:
        yield L  # 生成第0行，问题解决。
        。。。

咱们再来看看第1行的状况， T(1,0) == T(0,-1)+T(0,0) ,T(0,0)是1，T(0,-1)不存在。 T(1,1) == T(0,0)+T(0,1) ,T(0,0)是1，T(0,1)不存在 根据事实1，事实2 咱们知道T(1,0)和T(1,1)都是1,将已知量带入咱们的式子. 1 = x+1 得x=0 1 = 1+x 得x=0 发现了没有，要想让这个算法进行下去，第0行元素命格不行【八字欠零，五行(xing2)缺零】，一共缺了先后两个零。

#在假想的状况下，第0行若是能像图中这样补上两个0，那么生成第1行的时候就轻松愉快了。
#上边咱们分析过了生成第1行须要的T(0,-1)和T(0,1),如今已经到货.
r
0 [0 1 0]
1    1 1
2    1 2 1
3    1 3 3 1
4    1 4 6 4 1
------------------
c -1 0 1 2 3 4

那就这样定了，给第0行补0.

def triangles():
    L = [1]
    while True:
        yield L
        L.append(0) #做者真的给上一行补了0，但是为何只补了一个0？
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第1行

这里真的是巧合了！！！ 学习切片的时候，廖大说过列表倒数第一个元素的索引是-1。 因此，咱们在上图里看到的T(0,-1),在python列表里是绕到后边去了。 天然界里的列表[0,1,0],各元素索引依次为 -1,0,1 python里的列表[1,0],各元素索引依次为0,1/-1,就像一个环，两端粘在了一块儿。

看代码
def triangles():
    L = [1]
    while True:
        yield L
        L.append(0) #补完0后L的状态 [1,0] 
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第1行

已知 L:[1,0] ,len(L):2 ,range(0,2)不包含2
列表生成式[L[i - 1] + L[i] for i in range(len(L))]会生成什么鬼？
当i=0时 L[i-1]+L[i] == 0+1 == 1
当i=1时 L[i-1]+L[i] == 1+0 == 1
因此这个列表生成式最终生成了 [1,1],而后将它赋给L。而后yield L.

而后生成第2行：

def triangles():
    L = [1]
    while True:
        yield L #生成第2行时的开局状态，L:[1,1]
        L.append(0) #补0，[1,1,0]
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第2行

而后生成第3行。 而后生成第n行。。。

迭代器

咱们已经知道，能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

可使用isinstance()判断一个对象是不是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能够做用于for循环，还能够被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。

能够被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可使用isinstance()判断一个对象是不是Iterator对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为何list、dict、str等数据类型不是Iterator？

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。

Iterator甚至能够表示一个无限大的数据流，例如全体天然数。而使用list是永远不可能存储全体天然数的。

小结

凡是可做用于for循环的对象都是Iterable类型；

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

Python的for循环本质上就是经过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上彻底等价于：

# 首先得到Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 得到下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

高阶函数

高阶函数英文叫Higher-order function。什么是高阶函数？咱们以实际代码为例子，一步一步深刻概念。

变量能够指向函数

以Python内置的求绝对值的函数abs()为例，调用该函数用如下代码：

>>> abs(-10)
10

可是，若是只写abs呢？

>>> abs
<built-in function abs>

可见，abs(-10)是函数调用，而abs是函数自己。

要得到函数调用结果，咱们能够把结果赋值给变量：

>>> x = abs(-10)
>>> x
10

可是，若是把函数自己赋值给变量呢？

>>> f = abs
>>> f
<built-in function abs>

结论：函数自己也能够赋值给变量，即：变量能够指向函数。

若是一个变量指向了一个函数，那么，能否经过该变量来调用这个函数？用代码验证一下：

>>> f = abs
>>> f(-10)
10

成功！说明变量f如今已经指向了abs函数自己。直接调用abs()函数和调用变量f()彻底相同。

函数名也是变量

那么函数名是什么呢？函数名其实就是指向函数的变量！对于abs()这个函数，彻底能够把函数名abs当作变量，它指向一个能够计算绝对值的函数！

若是把abs指向其余对象，会有什么状况发生？

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把abs指向10后，就没法经过abs(-10)调用该函数了！由于abs这个变量已经不指向求绝对值函数而是指向一个整数10！

固然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。

注：因为abs函数其实是定义在import builtins模块中的，因此要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

传入函数

既然变量能够指向函数，函数的参数能接收变量，那么一个函数就能够接收另外一个函数做为参数，这种函数就称之为高阶函数。

一个最简单的高阶函数：

def add(x, y, f):
    return f(x) + f(y)

当咱们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs，根据函数定义，咱们能够推导计算过程为：

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

用代码验证一下：

>>> add(-5, 6, abs)
11

编写高阶函数，就是让函数的参数可以接收别的函数。

小结

把函数做为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

 

map/reduce

Python内建了map()和reduce()函数。

若是你读过Google的那篇大名鼎鼎的论文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。

咱们先看map。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次做用到序列的每一个元素，并把结果做为新的Iterator返回。

举例说明，好比咱们有一个函数f(x)=x2，要把这个函数做用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就能够用map()实现以下：

如今，咱们用Python代码实现：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()传入的第一个参数是f，即函数对象自己。因为结果r是一个Iterator，Iterator是惰性序列，所以经过list()函数让它把整个序列都计算出来并返回一个list。

你可能会想，不须要map()函数，写一个循环，也能够计算出结果：

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

的确能够，可是，从上面的循环代码，能一眼看明白“把f(x)做用在list的每个元素并把结果生成一个新的list”吗？

因此，map()做为高阶函数，事实上它把运算规则抽象了，所以，咱们不但能够计算简单的f(x)=x2，还能够计算任意复杂的函数，好比，把这个list全部数字转为字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

只须要一行代码。

再看reduce的用法。reduce把一个函数做用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素作累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就能够用reduce实现：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

固然求和运算能够直接用Python内建函数sum()，不必动用reduce。

可是若是要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就能够派上用场：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

这个例子自己没多大用处，可是，若是考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，咱们就能够写出把str转换为int的函数：

>>> from functools import reduce
>>> 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]
...
>>> reduce(fn, map(char2num, '13579'))
13579

整理成一个str2int的函数就是：

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))

也就是说，假设Python没有提供int()函数，你彻底能够本身写一个把字符串转化为整数的函数，并且只须要几行代码！

lambda函数的用法在后面介绍。

练习

利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其余小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

def normalize(name):
    new=""
    for n,x in enumerate(name):
        if n==0:
            new += x.upper()
        else:
            new += x.lower()
    return new

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

Python提供的sum()函数能够接受一个list并求和，请编写一个prod()函数，能够接受一个list并利用reduce()求积：

from functools import reduce

def prod(L):
    def fn(x,y):
        return x*y
    return reduce(fn,L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：

若是不利用map和reduce,答案：

def str2num(s):
    return{'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front = s[:n]
            end = s[n+1:]
            new = front + end
            return int(new)/fn(10,len(end))

都利用上map和reduce的答案：

from functools import reduce
def char2num(s):
    return {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'0':0}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def fn2(x,y):
    return x*10+y
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front=s[:n]
            end=s[n+1:]
            new=front+end
    return reduce(fn2,map(char2num,new))/fn(10,len(end))

print('str2float(\'123.456\') =', str2float('123.456'))

若是以上加上lambda使用：

from functools import reduce
def char2num(s):
    return {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'0':0}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front=s[:n]
            end=s[n+1:]
            new=front+end
    return reduce(lambda x,y:x*10+y,map(char2num,new))/fn(10,len(end))
 
print('str2float(\'123.456\') =', str2float('123.456'))

lambda的使用方法：

http://www.cnblogs.com/evening/archive/2012/03/29/2423554.html

 

filter

Python内建的filter()函数用于过滤序列。

和map()相似，filter()也接收一个函数和一个序列。和map()不一样的是，filter()把传入的函数依次做用于每一个元素，而后根据返回值是True仍是False决定保留仍是丢弃该元素。

例如，在一个list中，删掉偶数，只保留奇数，能够这么写：

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

把一个序列中的空字符串删掉，能够这么写：

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

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

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，因此要强迫filter()完成计算结果，须要用list()函数得到全部结果并返回list。

用filter求素数

计算素数的一个方法是埃氏筛法，它的算法理解起来很是简单：

首先，列出从2开始的全部天然数，构造一个序列：

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取序列的第一个数2，它必定是素数，而后用2把序列的2的倍数筛掉：

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数3，它必定是素数，而后用3把序列的3的倍数筛掉：

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数5，而后用5把序列的5的倍数筛掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不断筛下去，就能够获得全部的素数。

用Python来实现这个算法，能够先构造一个从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) # 构造新序列

这个生成器先返回第一个素数2，而后，利用filter()不断产生筛选后的新的序列。

因为primes()也是一个无限序列，因此调用时须要设置一个退出循环的条件：

# 打印1000之内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

注意到Iterator是惰性计算的序列，因此咱们能够用Python表示“全体天然数”，“全体素数”这样的序列，而代码很是简洁。

练习

回数是指从左向右读和从右向左读都是同样的数，例如12321，909。请利用filter()滤掉非回数：

答案：

def is_palindrome(n):
    s = str(n)
    return s==s[::-1]:
        
output = filter(is_palindrome, range(1, 1000))
print(list(output))

小结

filter()的做用是从一个序列中筛出符合条件的元素。因为filter()使用了惰性计算，因此只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。

sorted

排序算法

排序也是在程序中常常用到的算法。不管使用冒泡排序仍是快速排序，排序的核心是比较两个元素的大小。若是是数字，咱们能够直接比较，但若是是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，所以，比较的过程必须经过函数抽象出来。

Python内置的sorted()函数就能够对list进行排序：

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

此外，sorted()函数也是一个高阶函数，它还能够接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

key指定的函数将做用于list的每个元素上，并根据key函数返回的结果进行排序。对比原始的list和通过key=abs处理过的list：

list = [36, 5, -12, 9, -21]

keys = [36, 5,  12, 9,  21]

而后sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：

keys排序结果 => [5, 9,  12,  21, 36]
                |  |    |    |   |
最终结果     => [5, 9, -12, -21, 36]

咱们再看一个字符串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

默认状况下，对字符串排序，是按照ASCII的大小比较的，因为'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

如今，咱们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，没必要对现有代码大加改动，只要咱们能用一个key函数把字符串映射为忽略大小写排序便可。忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。

这样，咱们给sorted传入key函数，便可实现忽略大小写的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

要进行反向排序，没必要改动key函数，能够传入第三个参数reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

从上述例子能够看出，高阶函数的抽象能力是很是强大的，并且，核心代码能够保持得很是简洁。

小结

sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。

练习

假设咱们用一组tuple表示学生名字和成绩：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

1.请用sorted()对上述列表分别按名字排序：

2.再按成绩从高到低排序：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return t[0]
def by_score(t):
    return t[1]

L1 = sorted(L,key=by_name)
L2 = sorted(L,key=by_score,reverse=True)

print(L1)
print(L2)

返回函数

函数做为返回值

高阶函数除了能够接受函数做为参数外，还能够把函数做为结果值返回。

咱们来实现一个可变参数的求和。一般状况下，求和的函数是这样定义的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

可是，若是不须要马上求和，而是在后面的代码中，根据须要再计算怎么办？能够不返回求和的结果，而是返回求和的函数：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

当咱们调用lazy_sum()时，返回的并非求和结果，而是求和函数：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

调用函数f时，才真正计算求和的结果：

>>> f()
25

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

请再注意一点，当咱们调用lazy_sum()时，每次调用都会返回一个新的函数，即便传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响。

闭包

注意到返回的函数在其定义内部引用了局部变量args，因此，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，因此，闭包用起来简单，实现起来可不容易。

另外一个须要注意的问题是，返回的函数并无马上执行，而是直到调用了f()才执行。咱们来看一个例子：

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

f1, f2, f3 = count() #见注释

在上面的例子中，每次循环，都建立了一个新的函数，而后，把建立的3个函数都返回了。

你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

所有都是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

再看看结果：

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

缺点是代码较长，可利用lambda函数缩短代码。

小结

一个函数能够返回一个计算结果，也能够返回一个函数。

返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。

注释: 

f1,f2,f3 = count()

python 支持这种赋值方式

a,b,c=[1,2,3]

a,b,c=(1,2,3)

a,b,c=1,2,3

主要是python的赋值方式.前面的章节绝对没有讲解过.对小白的我产生了很大的困惑.

count函数运行完之后， fs = [f, f, f]

f1, f2, f3 = count() 至关于 [f1, f2, f3] = [f, f, f] 至关于 f1 = f f2 = f f3 = f f函数返回的是i的平方，i是3，因此返回9, 9, 9

匿名函数

当咱们在传入函数时，有些时候，不须要显式地定义函数，直接传入匿名函数更方便。

在Python中，对匿名函数提供了有限支持。仍是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还能够直接传入匿名函数：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

经过对比能够看出，匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。此外，匿名函数也是一个函数对象，也能够把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

一样，也能够把匿名函数做为返回值返回，好比：

def build(x, y):
    return lambda: x * x + y * y

详解：

#!/usr/bin/python
# -*- coding: utf-8 -*-

# 匿名函数lambda使用，上节中学习了 “返回函数” 这节学习了 “匿名函数”
# （1）、若是你定义一个有参数的函数，返回函数是一个无参函数，
# 那么将定义的有参函数赋值给一个变量(赋值后变量指针指向函数，这时变量就是函数的别名)时，
# 须要转递参数，调用函数变量就等于执行函数体
# （2）、若是你定义一个无参数的函数，返回函数是一个有参函数，
# 那么将定义的无参函数赋值给一个变量(赋值后变量指针指向函数，这时变量就是函数的别名)时，
# 不须要转递参数，调用函数变量时传递参数就等于执行函数体

# 返回函数
def build_return_func1(x, y):
    def g():
        return x**2 + y**2
    return g
# 返回lambda匿名函数
def build_return_lambda1(x, y):
    # 无参数lambda匿名函数
    return lambda: x ** 2 + y ** 2

# 有函数调用
f1 = build_return_func1(1, 2)
f2 = build_return_lambda1(2, 4)
print(f1())
print(f2())

 

5
20

 

# 返回函数
def build_return_func2():
    def g(x, y):
        return x**2 + y**2
    return g
# 返回lambda匿名函数
def build_return_lambda2():
    # 有参数lambda匿名函数
    return lambda x, y: x ** 2 + y ** 2

# 无函数调用
f3 = build_return_func2()
f4 = build_return_lambda2()
print(f3(1, 2))
print(f4(2, 4))

　　

5
20

 

小结

Python对匿名函数的支持有限，只有一些简单的状况下可使用匿名函数。

 

装饰器

因为函数也是一个对象，并且函数对象能够被赋值给变量，因此，经过变量也能调用该函数。

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

函数对象有一个__name__属性，能够拿到函数的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

如今，假设咱们要加强now()函数的功能，好比，在函数调用先后自动打印日志，但又不但愿修改now()函数的定义，这种在代码运行期间动态增长功能的方式，称之为“装饰器”（Decorator）。

本质上，decorator就是一个返回函数的高阶函数。因此，咱们要定义一个能打印日志的decorator，能够定义以下：

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

观察上面的log，由于它是一个decorator，因此接受一个函数做为参数，并返回一个函数。咱们要借助Python的@语法，把decorator置于函数的定义处：

@log
def now():
    print('2015-3-25')

调用now()函数，不只会运行now()函数自己，还会在运行now()函数前打印一行日志：

>>> now()
call now():
2015-3-25

把@log放到now()函数的定义处，至关于执行了语句：

now = log(now)

因为log()是一个decorator，返回一个函数，因此，原来的now()函数仍然存在，只是如今同名的now变量指向了新的函数，因而调用now()将执行新函数，即在log()函数中返回的wrapper()函数。

wrapper()函数的参数定义是(*args, **kw)，所以，wrapper()函数能够接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

若是decorator自己须要传入参数，那就须要编写一个返回decorator的高阶函数，写出来会更复杂。好比，要自定义log的文本：

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

这个3层嵌套的decorator用法以下：

@log('execute')
def now():
    print('2015-3-25')

执行结果以下：

>>> now()
execute now():
2015-3-25

和两层嵌套的decorator相比，3层嵌套的效果是这样的：

>>> now = log('execute')(now)

咱们来剖析上面的语句，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

以上两种decorator的定义都没有问题，但还差最后一步。由于咱们讲了函数也是对象，它有__name__等属性，但你去看通过decorator装饰以后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：

>>> now.__name__
'wrapper'

由于返回的那个wrapper()函数名字就是'wrapper'，因此，须要把原始函数的__name__等属性复制到wrapper()函数中，不然，有些依赖函数签名的代码执行就会出错。

不须要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，因此，一个完整的decorator的写法以下：

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

或者针对带参数的decorator：

import functools

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

import functools是导入functools模块。模块的概念稍候讲解。如今，只需记住在定义wrapper()的前面加上@functools.wraps(func)便可。

小结

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式须要经过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator能够用函数实现，也能够用类实现。

decorator能够加强函数的功能，定义起来虽然有点复杂，但使用起来很是灵活和方便。

1.请编写一个decorator，能在函数调用的先后打印出'begin call'和'end call'的日志。

2.再思考一下可否写出一个@log的decorator，使它既支持：

@log
def f():
    pass

又支持：

@log('execute')
def f():
    pass

两题混写成一个答案：

def log(text=None):
    def decorator(func):
        def wrapper(*args, **kw):
            print('begin call')
            result = func(*args,**kw)
            print('%s %s();' % (text,func.__name__))
            print('begin call')
            return result
        return wrapper
    return decorator

@log('execute')
def now(x=5):
    return print(x ** 2)

now(7)

偏函数

Python的functools模块提供了不少有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不同。

在介绍函数参数的时候，咱们讲到，经过设定参数的默认值，能够下降函数调用的难度。而偏函数也能够作到这一点。举例以下：

int()函数能够把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

>>> int('12345')
12345

但int()函数还提供额外的base参数，默认值为10。若是传入base参数，就能够作N进制的转换：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)很是麻烦，因而，咱们想到，能够定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):
    return int(x, base)

这样，咱们转换二进制就很是方便了：

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial就是帮助咱们建立一个偏函数的，不须要咱们本身定义int2()，能够直接使用下面的代码建立一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

因此，简单总结functools.partial的做用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

注意到上面的新的int2函数，仅仅是把base参数从新设定默认值为2，但也能够在函数调用时传入其余值：

>>> int2('1000000', base=10)
1000000

最后，建立偏函数时，实际上能够接收函数对象、*args和**kw这3个参数，当传入：

int2 = functools.partial(int, base=2)

实际上固定了int()函数的关键字参数base，也就是：

int2('10010')

至关于：

kw = { 'base': 2 }
int('10010', **kw)

当传入:

max2 = functools.partial(max, 10)

实际上会把10做为*args的一部分自动加到左边，也就是：

max2(5, 6, 7)

至关于：

args = (10, 5, 6, 7)
max(*args)

结果为10。

小结

当函数的参数个数太多，须要简化时，使用functools.partial能够建立一个新的函数，这个新函数能够固定住原函数的部分参数，从而在调用时更简单。

 

使用模块

Python自己就内置了不少很是有用的模块，只要安装完毕，这些模块就能够马上使用。

咱们之内建的sys模块为例，编写一个hello的模块：

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

' a test module '

__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
            print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

第1行和第2行是标准注释，第1行注释可让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件自己使用标准UTF-8编码；

第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；

第6行使用__author__变量把做者写进去，这样当你公开源代码后别人就能够瞻仰你的大名；

以上就是Python模块的标准文件模板，固然也能够所有删掉不写，可是，按标准办事确定没错。

后面开始就是真正的代码部分。

你可能注意到了，使用sys模块的第一步，就是导入该模块：

import sys

导入sys模块后，咱们就有了变量sys指向该模块，利用sys这个变量，就能够访问sys模块的全部功能。

sys模块有一个argv变量，用list存储了命令行的全部参数。argv至少有一个元素，由于第一个参数永远是该.py文件的名称，例如：

运行python3 hello.py得到的sys.argv就是['hello.py']；

运行python3 hello.py Michael得到的sys.argv就是['hello.py', 'Michael]。

最后，注意到这两行代码：

if __name__=='__main__':
    test()

当咱们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而若是在其余地方导入该hello模块时，if判断将失败，所以，这种if测试可让一个模块经过命令行运行时执行一些额外的代码，最多见的就是运行测试。

咱们能够用命令行运行hello.py看看效果：

$ python3 hello.py
Hello, world!
$ python hello.py Michael
Hello, Michael!

若是启动Python交互环境，再导入hello模块：

$ python3
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello
>>>

导入时，没有打印Hello, word!，由于没有执行test()函数。

调用hello.test()时，才能打印出Hello, word!：

>>> hello.test()
Hello, world!

做用域

在一个模块中，咱们可能会定义不少函数和变量，但有的函数和变量咱们但愿给别人使用，有的函数和变量咱们但愿仅仅在模块内部使用。在Python中，是经过_前缀来实现的。

正常的函数和变量名是公开的（public），能够被直接引用，好比：abc，x123，PI等；

相似__xxx__这样的变量是特殊变量，能够被直接引用，可是有特殊用途，好比上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也能够用特殊变量__doc__访问，咱们本身的变量通常不要用这种变量名；

相似_xxx和__xxx这样的函数或变量就是非公开的（private），不该该被直接引用，好比_abc，__abc等；

之因此咱们说，private函数和变量“不该该”被直接引用，而不是“不能”被直接引用，是由于Python并无一种方法能够彻底限制访问private函数或变量，可是，从编程习惯上不该该引用private函数或变量。

private函数或变量不该该被别人引用，那它们有什么用呢？请看例子：

def _private_1(name):
    return 'Hello, %s' % name

def _private_2(name):
    return 'Hi, %s' % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

咱们在模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来了，这样，调用greeting()函数不用关心内部的private函数细节，这也是一种很是有用的代码封装和抽象的方法，即：

外部不须要引用的函数所有定义成private，只有外部须要引用的函数才定义为public。

__name__ = '__main__' 的做用解释：

http://www.jb51.net/article/51892.htm

 

安装第三方模块

在Python中，安装第三方模块，是经过包管理工具pip完成的。

若是你正在使用Mac或Linux，安装pip自己这个步骤就能够跳过了。

若是你正在使用Windows，请参考安装Python一节的内容，确保安装时勾选了pip和Add python.exe to Path。

在命令提示符窗口下尝试运行pip，若是Windows提示未找到命令，能够从新运行安装程序添加pip。

注意：Mac或Linux上有可能并存Python 3.x和Python 2.x，所以对应的pip命令是pip3。

如今，让咱们来安装一个第三方库——Python Imaging Library，这是Python下很是强大的处理图像的工具库。不过，PIL目前只支持到Python 2.7，而且有年头没有更新了，所以，基于PIL的Pillow项目开发很是活跃，而且支持最新的Python 3。

通常来讲，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，能够在官网或者pypi上搜索，好比Pillow的名称叫Pillow，所以，安装Pillow的命令就是：

pip install Pillow

耐心等待下载并安装后，就可使用Pillow了。

有了Pillow，处理图片易如反掌。随便找个图片生成缩略图：

>>> from PIL import Image
>>> im = Image.open('test.png')
>>> print(im.format, im.size, im.mode)
PNG (400, 300) RGB
>>> im.thumbnail((200, 100))
>>> im.save('thumb.jpg', 'JPEG')

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

模块搜索路径

当咱们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件，若是找不到，就会报错：

>>> import mymodule
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named mymodule

默认状况下，Python解释器会搜索当前目录、全部已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中：

>>> import sys
>>> sys.path
['', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python34.zip', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/plat-darwin', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/site-packages']

若是咱们要添加本身的搜索目录，有两种方法：

一是直接修改sys.path，添加要搜索的目录：

>>> import sys
>>> sys.path.append('/Users/michael/my_py_scripts')

这种方法是在运行时修改，运行结束后失效。

第二种方法是设置环境变量PYTHONPATH，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量相似。注意只须要添加你本身的搜索路径，Python本身自己的搜索路径不受影响。