您的位置：首页 > 编程语言 > Python开发

Python 3 学习笔记2

2016-11-29 09:52 239 查看

教程链接：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]

表示，从索引

开始取，直到索引

为止，但不包括索引

。即索引

，

，正好是3个元素。

如果第一个索引是

，还可以省略：

>>> 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
1、L[n1:n2:n3]
n1代表开始元素下标
n2代表结束元素下标
n3代表切片间隔以及切片方向
L中每个元素都有正负两种下标，例如L[0]和L[-10]指的同一个元素都是0
2、L[::1]与L[::-1]
在L[::1]中n1是0(-10)，n2是9(-1)
在L[::-1]中n1是9(-1),n2是0(-10)
3、L[-1:1]是多少？
答案是[]，因为L[-1:1]的完全表示方式是L[-1:1:1],翻译出来就是
：从下标为-1的元素开始，以正方向切片到下标为1的元素。但是python从下标为-1的元素以正方向切片到列表结束也没有发现下标为1的元素，那么L[-1:1]的计算结果就是[].
4、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>

创建

和

的区别仅在于最外层的

[]

和

()

，

是一个list，而

是一个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)

，就计算出

的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出

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 + bn = 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 = 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

成功！说明变量

现在已经指向了

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

指向

后，就无法通过

abs(-10)

调用该函数了！因为

abs

这个变量已经不指向求绝对值函数而是指向一个整数

！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复

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)

时，参数

，

和

分别接收

-5

，

和

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

传入的第一个参数是

，即函数对象本身。由于结果

是一个

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]

变换成整数

，

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, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取序列的第一个数

，它一定是素数，然后用

把序列的

的倍数筛掉：

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

取新序列的第一个数

，它一定是素数，然后用

把序列的

的倍数筛掉：

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

取新序列的第一个数

，然后用

把序列的

的倍数筛掉：

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

不断筛下去，就可以得到所有的素数。

用Python来实现这个算法，可以先构造一个从

开始的奇数序列：

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) # 构造新序列

这个生成器先返回第一个素数

，然后，利用

filter()

不断产生筛选后的新的序列。

由于

primes()

也是一个无限序列，所以调用时需要设置一个退出循环的条件：

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

注意到

Iterator

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

练习

回数是指从左向右读和从右向左读都是一样的数，例如

，

。请利用

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'

，结果，大写字母

会排在小写字母

的前面。

现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能用一个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()
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()

结果应该是

，

，但实际结果是：

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

全部都是

！原因就在于返回的函数引用了变量

，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量

已经变成了

，因此最终结果为

。

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

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

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

表示匿名函数，冒号前面的

表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写

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

参数，默认值为

。如果传入

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

参数重新设定默认值为

，但也可以在函数调用时传入其他值：

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

实际上会把

作为

*args

的一部分自动加到左边，也就是：

max2(5, 6, 7)

相当于：

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

结果为

。

小结

当函数的参数个数太多，需要简化时，使用

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自己本身的搜索路径不受影响。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

Python 3 学习笔记2

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

高级特性

切片

小结

迭代

小结

列表生成式

练习

生成器

练习

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

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

迭代器

小结

高阶函数

变量可以指向函数

函数名也是变量

传入函数

小结

map/reduce

练习

filter

用filter求素数

练习

小结

sorted

排序算法

小结

练习

返回函数

函数作为返回值

闭包

小结

匿名函数

小结

装饰器

小结

偏函数

小结

使用模块

作用域

__name__ = '__main__' 的作用解释：

安装第三方模块

模块搜索路径

name = 'main' 的作用解释：