本節摘要：切片；迭代；列表生成器；生成器 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 "<stdin>", 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 "<stdin>", 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 "<stdin>", line 1, in <module>
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
<generator object <genexpr> 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 object fib at 0x109b9fb90>
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 "<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中，具體操作會在后面介紹。
? 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 "<stdin>", line 1, in <module>
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
<generator object fib at 0x1022ef948>
迭代器 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
