python基礎之切片、迭代和列表生成式
取一個list的部分元素是非常常見的操作。比如，一個list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
取前3個元素，應該怎麼做？
笨辦法：
>>> [L[0], L[1], L[2]] ['Adam', 'Lisa', 'Bart']
之所以是笨辦法是因為擴充套件一下，取前N個元素就沒轍了。
取前N個元素，也就是索引為0-(N-1)的元素，可以用迴圈：
>>> r = [] >>> n = 3 >>> for i in range(n): ... r.append(L[i]) ... >>> r ['Adam', 'Lisa', 'Bart']
對這種經常取指定索引範圍的操作，用迴圈十分繁瑣，因此，Python提供了切片（Slice）操作符，能大大簡化這種操作。
對應上面的問題，取前3個元素，用一行程式碼就可以完成切片：
>>> L[0:3] ['Adam', 'Lisa', 'Bart']
L[0:3]表示，從索引0開始取，直到索引3為止，但不包括索引3。即索引0，1，2，正好是3個元素。
如果第一個索引是0，還可以省略：
>>> L[:3] ['Adam', 'Lisa', 'Bart']
也可以從索引1開始，取出2個元素出來：
>>> L[1:3] ['Lisa', 'Bart']
只用一個 : ，表示從頭到尾：
>>> L[:] ['Adam', 'Lisa', 'Bart', 'Paul']
因此，L[:]實際上覆製出了一個新list。
切片操作還可以指定第三個引數：
>>> L[::2] ['Adam', 'Bart']
第三個引數表示每N個取一個，上面的 L[::2] 會每兩個元素取出一個來，也就是隔一個取一個。
把list換成tuple，切片操作完全相同，只是切片的結果也變成了tuple。
2、倒序切片
對於list，既然Python支援L[-1]取倒數第一個元素，那麼它同樣支援倒數切片，試試：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul'] >>> L[-2:] ['Bart', 'Paul'] >>> L[:-2] ['Adam', 'Lisa'] >>> L[-3:-1] ['Lisa', 'Bart'] >>> L[-4:-1:2] ['Adam', 'Bart']
記住倒數第一個元素的索引是-1。倒序切片包含起始索引，不包含結束索引。
3、對字串切片
字串 'xxx'和 Unicode字串 u'xxx'也可以看成是一種list，每個元素就是一個字元。因此，字串也可以用切片操作，只是操作結果仍是字串：
>>> 'ABCDEFG'[:3] 'ABC' >>> 'ABCDEFG'[-3:] 'EFG' >>> 'ABCDEFG'[::2] 'ACEG'
在很多程式語言中，針對字串提供了很多各種擷取函式，其實目的就是對字串切片。Python沒有針對字串的擷取函式，只需要切片一個操作就可以完成，非常簡單。
迭代
1、什麼是迭代
在Python中，如果給定一個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上，還可以作用在其他任何可迭代物件上。
因此，迭代操作就是對於一個集合，無論該集合是有序還是無序，我們用 for 迴圈總是可以依次取出集合的每一個元素。
注意: 集合是指包含一組元素的資料結構，我們已經介紹的包括： 1. 有序集合：list，tuple，str和unicode； 2. 無序集合：set 3. 無序集合並且具有 key-value 對：dict
而迭代是一個動詞，它指的是一種操作，在Python中，就是 for 迴圈。
迭代與按下標訪問陣列最大的不同是，後者是一種具體的迭代實現方式，而前者只關心迭代結果，根本不關心迭代內部是如何實現的
2、索引迭代
Python中，迭代永遠是取出元素本身，而非元素的索引。
對於有序集合，元素確實是有索引的。有的時候，我們確實想在 for 迴圈中拿到索引，怎麼辦？
方法是使用 enumerate() 函式：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul'] >>> for index, name in enumerate(L): ... print index, '-', name ... 0 - Adam 1 - Lisa 2 - Bart 3 - Paul
使用 enumerate() 函式，我們可以在for迴圈中同時繫結索引index和元素name。但是，這不是 enumerate() 的特殊語法。實際上，enumerate() 函式把：
['Adam', 'Lisa', 'Bart', 'Paul']
變成了類似：
[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
因此，迭代的每一個元素實際上是一個tuple：
for t in enumerate(L): index = t[0] name = t[1] print index, '-', name
如果我們知道每個tuple元素都包含兩個元素，for迴圈又可以進一步簡寫為：
for index, name in enumerate(L): print index, '-', name
這樣不但程式碼更簡單，而且還少了兩條賦值語句。
可見，索引迭代也不是真的按索引訪問，而是由 enumerate() 函式自動把每個元素變成 (index, element) 這樣的tuple，再迭代，就同時獲得了索引和元素本身。
zip()函式可以把兩個 list 變成一個 list：
>>> zip([10, 20, 30], ['A', 'B', 'C']) [(10, 'A'), (20, 'B'), (30, 'C')]
3、迭代dict的value
我們已經瞭解了dict物件本身就是可迭代物件，用 for 迴圈直接迭代 dict，可以每次拿到dict的一個key。
如果我們希望迭代 dict 物件的value，應該怎麼做？
dict 物件有一個 values() 方法，這個方法把dict轉換成一個包含所有value的list，這樣，我們迭代的就是 dict的每一個 value：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values(): print v
# 85
# 95
# 59
如果仔細閱讀Python的文件，還可以發現，dict除了values()方法外，還有一個 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一樣：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
print v
# 85
# 95
# 59
那這兩個方法有何不同之處呢？
1. values() 方法實際上把一個 dict 轉換成了包含 value 的list。
2. 但是 itervalues() 方法不會轉換，它會在迭代過程中依次從 dict 中取出 value，所以 itervalues() 方法比 values() 方法節省了生成 list 所需的記憶體。
3. 列印 itervalues() 發現它返回一個 <dictionary-valueiterator> 物件，這說明在Python中，for 迴圈可作用的迭代物件遠不止 list，tuple，str，unicode，dict等，任何可迭代物件都可以作用於for迴圈，而內部如何迭代我們通常並不用關心。
如果一個物件說自己可迭代，那我們就直接用 for 迴圈去迭代它，可見，迭代是一種抽象的資料操作，它不對迭代物件內部的資料有任何要求。
4、迭代dict的key和value
我們瞭解瞭如何迭代 dict 的key和value，那麼，在一個 for 迴圈中，能否同時迭代 key和value？答案是肯定的。
首先，我們看看 dict 物件的 items() 方法返回的值：
>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]
可以看到，items() 方法把dict物件轉換成了包含tuple的list，我們對這個list進行迭代，可以同時獲得key和value：
>>> for key, value in d.items(): ... print key, ':', value ... Lisa : 85 Adam : 95 Bart : 59
和 values() 有一個 itervalues() 類似， items() 也有一個對應的 iteritems()，iteritems() 不把dict轉換成list，而是在迭代過程中不斷給出 tuple，所以， iteritems() 不佔用額外的記憶體。
列表生成式
1、生成列表
要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我們可以用range(1, 11)：
>>> 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]
這種寫法就是Python特有的列表生成式。利用列表生成式，可以以非常簡潔的程式碼生成 list。
寫列表生成式時，把要生成的元素 x * x 放到前面，後面跟 for 迴圈，就可以把list創建出來，十分有用，多寫幾次，很快就可以熟悉這種語法。
2、複雜表示式
使用for迴圈的迭代不僅可以迭代普通的list，還可以迭代dict。
假設有如下的dict：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
完全可以通過一個複雜的列表生成式把它變成一個 HTML 表格：
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()] print '<table>' print '<tr><th>Name</th><th>Score</th><tr>' print '\n'.join(tds) print '</table>'
注：字串可以通過 % 進行格式化，用指定的引數替代%s。字串的join()方法可以把一個 list 拼接成一個字串。
把打印出來的結果儲存為一個html檔案，就可以在瀏覽器中看到效果了：
<table border="1"> <tr><th>Name</th><th>Score</th><tr> <tr><td>Lisa</td><td>85</td></tr> <tr><td>Adam</td><td>95</td></tr> <tr><td>Bart</td><td>59</td></tr> </table>
3、條件過濾
列表生成式的 for 迴圈後面還可以加上 if 判斷。例如：
>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
如果我們只想要偶數的平方，不改動 range()的情況下，可以加上 if 來篩選：
>>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]
有了 if 條件，只有 if 判斷為 True 的時候，才把迴圈的當前元素新增到列表中。
4、多層表示式
for迴圈可以巢狀，因此，在列表生成式中，也可以用多層 for 迴圈來生成列表。
對於字串 'ABC' 和 '123'，可以使用兩層迴圈，生成全排列：
>>> [m + n for m in 'ABC' for n in '123'] ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
翻譯成迴圈程式碼就像下面這樣：
L = [] for m in 'ABC': for n in '123': L.append(m + n)