本节摘要：切片；迭代；列表生成器；生成器 generator；迭代器 iterator
Daily Record：每天一纪念，记录下python的学习历程，入门学习笔记与心得。本学习笔记主要基于廖雪峰大大的Python教程。不积跬步，无以至千里～ .ﾟ(ง •̀_•́)ง
@[toc]
在Python中，代码不是越多越好，而是越少越好。代码不是越复杂越好，而是越简单越好。代码越少，开发效率越高。
高级特性
切片
取一个list或tuple的部分元素，例如：
>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> [L[0], L[1], L[2]] # 取前3个元素
['Michael', 'Sarah', 'Tracy']
取前N个元素，也就是索引为0-(N-1)的元素，可以用循环：
>>> r = []
>>> n = 3
>>> for i in range(n):
... r.append(L[i])
...
>>> r
['Michael', 'Sarah', 'Tracy']
对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。
slice，即切片的意思。在Python中可以用切片的方式来取一个list、tuple或者是字符串的其中一部分。
对应上面的问题，取前3个元素，用一行代码就可以完成切片：
>>> L[0:3] # L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
['Michael', 'Sarah', 'Tracy']
如果第一个索引是0，还可以省略：
>>> L[:3]
['Michael', 'Sarah', 'Tracy']
>>> L[1:3] # 从索引1开始，取出2个元素出来
['Sarah', 'Tracy']
既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片：
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1] # 倒数第一个元素的索引是-1
['Bob']
例子，创建一个0到100的list：
>>> L = list(range(0,101)) #创建一个0到100的list
>>> L
[0, 1, 2, 3, ..., 100]
>>> L[1:10] #取索引1开始，到索引10为止但不含10的元素
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[0:10] #取索引0开始，到索引10为止但不含10的元素
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[:10] #如果从索引0开始取，那么0可以省略
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[:] #取所有元素，原样复制一个list
[0, 1, 2, 3, 4, 5...96, 97, 98, 99, 100]
也可以直接取后面的元素，需要注意的是第一个元素的索引号是0，倒数第一个元素的索引号是-1。切片必须顺序取值，如L[10:1]、L[-1:-10]都是无法取值的。
>>>L[-10:-1] #从索引-10开始到索引-1为止但不含-1的元素
[91, 92, 93, 94, 95, 96, 97, 98, 99]
>>>L[-10:] #取最后10个元素
[91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
后面再加一个冒号可以实现间隔取值，如
>>>L[:10:2] #从索引号0开始，每2个取1个，到索引号10为止不含10
[0, 2, 4, 6, 8]
>>>L[:30:3] #从索引号0开始，每3个取1个，到索引号30为止不含30
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：
>>>T=(0,1,2,3,4) #tuple切片
>>>T[1:3]
(1, 2)
字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'
>>> S='abcdef' #字符串切片
>>> S[1:3]
>>> 'bc'
在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。
有了切片操作，很多地方循环就不再需要了。Python的切片非常灵活，一行代码就可以实现很多行循环才能完成的操作。
【练习】去除字符串首尾空格的函数实现
利用切片操作，实现一个trim()函数，去除字符串首尾的空格，注意不要调用str的strip()方法：
【交作业】
- 掐头去尾 while循环1
# -*- coding: utf-8 -*-
def trim(s):
n = len(s)
i = 0
b = -1
while i <= n-1 and s[i] == ' ':
i = i + 1
while b >= -n and s[b] == ' ':
b = b - 1
s = s[i:b+1]
return s
print trim(' Hello ')
- while循环2
def trim(s):
n = 0
while len(s)!=0 and s[n] == ' ' and n < len(s)-1:
n+=1 # n = n + 1
m = -1
while len(s)!=0 and s[m] == ' ' and m > (-1)*len(s):
m-=1 # m = m - 1
ts = s[n:m+1] # ts = s[n:len(s)+(m+1)]
return ts
print trim(' Hello ')
- for in循环 加if
# -*- coding: utf-8 -*-
def trim(s):
start = 0
end = len(s)-1
for str in s:
if s[start] == ' ':
start = start + 1
elif s[end] == ' ':
end = end - 1
elif start == end:
return ' '
return s[start:end + 1]
print trim(' Hello ')
- 递归 左右循环
# -*- coding: utf-8 -*-
def trim(s):
if s[:1] == ' ':
return trim(s[1:])
elif s[-1:] == ' ':
return trim(s[:-1])
else:
return s
print trim(' Hello ')
def trim(s):
if len(s) == 0:
return ''
else:
if s[-1:] == ' ':
return trim(s[:-1])
elif s[:1] == ' ':
return trim(s[1:])
return s[:]
# -*- coding: utf-8 -*-
def trim(s):
while s[:1] == ' ':
s = s[1:]
while s[-1:] == ' ':
s = s[:-1]
return s
递归会出现函数调用栈溢出问题，当字符串前后空格长度为1000，程序就报错了
- 查找起始位置
def trim(s):
b = 0
e = len(s)
for i in range(e):
if s[i] != ' ':
break
b += 1
for i in range(e)[::-1]:
if s[i] != ' ':
break
e = i
return s[b:e]
def trim(s):
while s and s[0] == ' ': # while语句的判断条件中加上s，是为了排除s为空字符串的情况。因为s为空时，对变量s进行切片时，会报错“索引错误”。
s = s[1:]
while s and s[-1] == ' ':
s = s[:-1]
return s
迭代
Iteration，当我们用for循环来遍历list或tuple时，这种遍历就是Iteration，即迭代。
Python的for循环抽象程度要高于C的for循环，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。
在其他语言中如c，在迭代时需要通过下标来实现，而在Python中，没有下标也能实现迭代，Python的可迭代对象有很多，如list、tuple、dict、字符串等。
字符串也是可迭代对象，也可以作用于for循环：
>>> for ch in 'ABC':
... print ch
...
A
B
C
• 判断是否为可迭代对象
方法是通过collections模块的Iterable类型判断：
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
• 迭代tuple
>>> T = (1, 2, 3)
>>> for a in T: #迭代tuple
... print a
...
1
2
3
• 迭代dict中的key
>>> D = {'Zhao':20, 'Qian':50, 'Sun':100}
>>> for key in D: #迭代dict中的key
... print key
...
Sun # 因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。
Zhao
Qian
默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。
• 迭代dict中的value
>>> for value in D.values(): #迭代dict中的value
... print value
...
100
20
50
• 同时迭代dict中的key和value
>>> for k, v in D.items(): #同时迭代dict中的key和value
... print k, v
...
Sun 100
Zhao 20
Qian 50
• 拥有迭代下标
如果想要和其他语言类似Java一样想要有下标，可以通过Python内置的enumerate( )函数来实现，把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']):
... print i, value
...
0 A
1 B
2 C
>>>for i, a in enumerate(T): #同时迭代去索引和元素本身
... print i,a
...
0 1
1 2
2 3
上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如：
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
... print x, y
...
1 1
2 4
3 9
总结
任何可迭代对象都可以作用于for循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用for循环。
【练习】取list中的最大最小值的函数实现
请使用迭代查找一个list中最小和最大值，并返回一个tuple：
# -*- coding: utf-8 -*-
def findMinAndMax(L):
return (None, None)
【交作业】
# -*- coding: utf-8 -*-
def findMinAndMax(L):
if len(L) == 0:
return (None, None) # MIN=MAX=None
else:
min = L[0]
max = L[0]
for x in L:
if x < min:
min = x
elif x > max:
max = x
return (min, max)
L = [3, 6, 10]
print findMinAndMax(L)
# -*- coding: utf-8 -*-
def findMinAndMax(L):
if len(L) != 0:
maxnum = minnum = L[0]
for x in L:
maxnum = max(x, maxnum)
minnum = min(x, minnum)
return (minnum, maxnum)
else:
return (None, None)
# -*- coding: utf-8 -*-
def findMinAndMax(L):
if L == []:
return (None, None)
max, min = L[0], L[0]
for i in range(len(L)):
if L[i]>= max:
max = L[i]
elif L[i]< min:
min = L[i]
return (min, max)
列表生成式
列表生成器可通过[ ]直接构建。
我们想要生成一个列表的话可以先通过list(range(,))生成初始列表，然后在循环语句或判断语句加入条件与算法从而得到想要的列表，但这种方法有点麻烦。而列表生成器可以把这个过程用一行代码实现！
例如，要生成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]
要生成这样的数列：
方法一用循环：
>>> L = []
>>> for x in range(1, 11):
... L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
方法二用列表生成式（简单用一行语句就可以实现），写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来：
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
for循环后面还可以加上if判断，只算奇数的平方：
>>> [x * x for x in range(1, 11) if x % 2 != 0]
[1, 9, 25, 49, 81]
只筛选出仅偶数的平方：
>>> [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 "123"]
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
>>> [a + b for a in 'ABC' for b in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
三层和三层以上的循环就很少用到了。
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']
>>> D={'A':'a', 'B':'b', "C":'c'}
>>> [k + '-->' + v for k, v in D.items()]
['A-->a', 'C-->c', 'B-->b']
把一个list中所有的字符串变成小写：
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
if ... else
使用列表生成式的时候，要搞清楚if...else的用法。
例如，输出偶数：
>>> [x for x in range(1, 11) if x % 2 == 0]
[2, 4, 6, 8, 10]
但是，不能在最后的if加上else：
>>> [x for x in range(1, 11) if x % 2 == 0 else 0]
File "", line 1
[x for x in range(1, 11) if x % 2 == 0 else 0]
^
SyntaxError: invalid syntax
这是因为跟在for后面的if是一个筛选条件，不能带else，否则如何筛选？
另一些童鞋发现把if写在for前面必须加else，否则报错：
>>> [x if x % 2 == 0 for x in range(1, 11)]
File "", line 1
[x if x % 2 == 0 for x in range(1, 11)]
^
SyntaxError: invalid syntax
这是因为for前面的部分是一个表达式，它必须根据x计算出一个结果。因此，考察表达式：x if x % 2 == 0，它无法根据x计算出结果，因为缺少else，必须加上else：
>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
上述for前面的表达式x if x % 2 == 0 else -x才能根据x计算出确定的结果。
可见，在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。
总结
运用列表生成式，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分简洁。
【练习】
如果list中既包含字符串，又包含整数，由于非字符串类型没有lower()方法，所以列表生成式会报错：
>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'int' object has no attribute 'lower'
使用内建的isinstance函数可以判断一个变量是不是字符串：
>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False
请修改列表生成式，通过添加if语句保证列表生成式能正确地执行：
# -*- coding: utf-8 -*-
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = ???
【交作业】
>>> [x for x in L1 if isinstance(x, str)]
['Hello', 'World', 'Apple']
>>> [x.lower() for x in L1 if isinstance(x, str)]
['hello', 'world', 'apple']
生成器 generator
generator，是生产者的意思。在Python中，generator意为生成器，是一种可以一边循环一边计算的机制。相比列表生成式，generator的优点在于算法不用生成全部数列，而只生成我们需要的一部分，从而节省很多空间。
• generator的定义
generator的定义有两种方式:
第一种：是直接通过( )创建，这种方式与列表生成器相似，只是把[ ]换成( )。
>>> L = [x * x for x in range(1, 11)]
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> g = (x * x for x in range(1, 11))
>>> g
at 0x109b9fbe0>
第二种：是通过函数的形式创建，在定义函数的过程中加入yield关键字，yield后面需生成的值，则这个函数不是一个普通的函数而是一个generator。如我们可以构建一个斐波拉契数列生成器
著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print b
a, b = b, a + b
n = n + 1
赋值语句：a, b = b, a + b
相当于：
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]
上面的函数可以输出斐波那契数列的前N个数：
>>> f = fib(6)
1
1
2
3
5
8
要把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
>>> f = fib(6)
>>> f
generator和函数的执行流程不一样。直到return返回，则退出函数。而generator的执行方式是顺序执行，直到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)
step2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
File "", line 1, in
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中，具体操作会在后面介绍。
• generator的调用
打印出generator的每一个元，可以一个一个打印出来，可以通过next()函数获得generator的下一个返回值：
>>> 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)
100
>>> next(g)
Traceback (most recent call last):
File "", line 1, in
StopIteration
generator保存的是算法，每次调用next()，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
这种方式太过繁琐，generator是可迭代对象，一般采用for…in循环来调用。
>>> g = (x * x for x in range(1, 11))
>>> for n in g:
... print n
...
1
4
9
16
25
36
49
64
81
100
创建了一个generator后，基本上永远不会调用next()方法，而是通过for循环来迭代它。
【练习】杨辉三角排列的生成
杨辉三角定义如下：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
把每一行看做一个list，试写一个generator，不断输出下一行的list：
# -*- coding: utf-8 -*-
def triangles():
【交作业】
# -*- coding: utf-8 -*-
def triangles():
L = [1] #初始排列L为[1]
while True:
yield L #返回L
if L == [1]:
L = L + [1] #在L只有一个元素时，在加[1]，时排列为[1,1]
else:
L = [1]+[L[x]+L[x+1]for x in range(len(L)-1)]+[1]
#当排列L有两个或以上的元素时，按顺序把每两个值相加生成一个值，并在前后加[1]
n = 0
results = []
for t in triangles():
print(t)
results.append(t)
n = n + 1
if n == 10: #生成十行排列
break
输出结果
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
- 同一列表首尾插入项{0} ，形成2个不同的列表，错位相加生成新的列表
# -*- coding: utf-8 -*-
def triangles():
L = [1]
while True:
yield L
L1 = [0] + L
L2 = L + [0]
L = [L1[i]+L2[i] for i in range(0,len(L1))]
……
li = [1] # 错位相加即可
while True:
yield li[:]
li.append(0)
for index,value in enumerate(li[:-1]):
li[index+1] += value
?
def triangles():
L = [1]
yield L
n = 1 while True:
Ln = []
for i in range(n + 1):
if i == 0 or i == n:
Ln.append(1)
else:
Ln.append(L[n - 1][i - 1] + L[n - 1][i])
yield Ln
L.append(Ln)
n = n + 1
while True:
L = [1 if x == 0 or x == n else results[n-1][x-1]+results[n-1][x] for x in range(n+1)]
yield L
pass
总结
generator是非常强大的工具，在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。
要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。
注意区分普通函数和generator函数，普通函数调用直接返回结果：
>>> r = abs(6)
>>> r
6
generator函数的“调用”实际返回一个generator对象：
>>> g = fib(6)
>>> g
迭代器 Iterator
• 可迭代对象 Iterable
可用for循环来迭代的对象称可迭代对象——Iterable，包括list、tuple、set、str、generator。
Python3中可通过isinstance()来判断一个对象是否为可迭代对象：
>>> from collections.abc import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(5, Iterable)
False
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
• 迭代器 Iterator
可以被next( )函数调用不断返回下个值得对象称迭代器——Iterator，如generator。可通过isinstance()来判断一个对象是否为迭代器。
>>> from collections.abc import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abcd', Iterator)
False
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是`Iterator。
• Iterable转成Iterator
可以通过 iter() 函数把list、dict、str等Iterable可迭代对象转成Iterator迭代器。
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abcd'), Iterator)
True
总结
凡是可作用于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