Python編程核心內容之二——切片、迭代和列表生成式

　　Python版本：3.6.2  操做系統：Windows  做者：SmallWZQ

　　最近太忙啦。不少事情須要本身處理，感受時間不夠用啊~~~~從此，博客更新時間可能會慢下來（但不能荒廢了學習，要學習就得進行總結，哪怕借鑑前輩的學習資料），所以，不管閒忙，老是要學會總結。哈哈，正所謂「人不爲己，天誅地滅」嘛。嘿嘿，沒這麼回事，說笑的……好像又扯遠了。OK，迴歸正題，下面將回到Python先~~~

　　Python編程中，你若是要編寫出不少有用的程序，必須掌握數據類型、語句和函數。對於Python編程，原則有二：一是代碼不是越多越好，而是越少越好；二是代碼不是越複雜越好，而是越簡單越好。你還想「一行代碼兩塊錢」。效率決定一切。

　　下面來個例子（否則，全是文字，會暈~~~）【實現1,3,5,7,9，……99的列表】：

 1 #賺錢版代碼
 2 >>>n = 1
 3 >>>L = []  4 >>>while n <= 99:  5 ... L.append(n)  6 ...    n = n + 2
 7 ...  8 >>>print(L)        #好多money，但老闆不必定會給噢
 9 #略縮版代碼
10 >>>L= list(range(1,100,2)) 11 >>>print(L) 12 #終極版代碼
13 >>>[x for x in range(1,100,2)]

　　其實，上述代碼涉及到的代碼主要包括循環、range()、分片、列表生成式。經過例子，咱們知道：Python提供了不少有用的高級特性，靈活運用這些特性，能夠減小咱們不少代碼量，提升效率。

切片

　　切片是Python編程的高級特性之一。切片能夠訪問必定範圍內的元素，經過冒號（:）【該冒號是英文版的】隔開兩個索引實現。

　　關於Python編程中的符號（好比冒號，逗號，括號……）都是英文版的【重要的事情說好多遍，由於本身平時編程也會時常出現這類錯誤】，不然程序編譯會有Error，並且這種類型的錯誤還很差發現。所以，細節決定高度~~~

1 #切片的魔力
2 >>>L = [1,2,3,4,5,6,7,8,9,10] 3 >>>L[2:5] 4 3,4,5
5 >>>L[0:1] 6 1

　　切片操做的實現須要提供兩個索引做爲邊界，第一個索引的元素是包含在切片內的，而第二個則不包含在切片內。

　　注：若是第一個索引是0，能夠省略：

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

　　既然Python支持L[-1]取倒數第一個元素，那麼它一樣支持倒數切片:

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

　　Python 3.x版本中，切片操做還支持步長：

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

　　tuple也是一種list，惟一區別是tuple不可變。所以，tuple也能夠用切片操做，只是操做的結果還是tuple：

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

　　字符串’xxx’也能夠當作是一種list，每一個元素就是一個字符。所以，字符串也能夠用切片操做，只是操做結果還是字符串：

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

　　Python沒有針對字符串的截取函數，只須要切片一個操做就能夠完成，很是簡單。

　　Python的切片很是靈活，一行代碼就能夠實現不少行循環才能完成的操做。

迭代

　　Iteration是Python編程中最重要的高級特性。迭代（Iteration）：給定一個list或tuple，經過for循環來遍歷這個list或tuple。故而，Python是經過for...in循環實現迭代的。

　　list這種數據類型雖然有下標，但不少其餘數據類型是沒有下標的，可是，只要是可迭代對象，不管有無下標，均可以迭代，好比dict就能夠迭代：

1 >>> d = {'A': 1, 'B': 2, 'C': 3} 2 >>> for key in d: 3 ...    print(key) 4 ... 5 A 6 B 7 C 8 >>>　

　　由於dict的存儲不是按照list的方式順序排列，因此，迭代出的結果順序極可能不同。

　　默認狀況下，dict迭代的是key。若是要迭代value，能夠用for value in d.values()，若是要同時迭代key和value，能夠用for k, v in d.items()。

　　因爲字符串也是可迭代對象，所以，也能夠做用於for循環：

1 >>> for ch in 'ABC': 2 ...     print(ch) 3 ... 4 A 5 B 6 C

　　所以，當咱們使用for循環時，只要做用於一個可迭代對象，for循環就能夠正常運行，而咱們不太關心該對象到底是list仍是其餘數據類型。

　　那麼，如何判斷一個對象是可迭代對象呢？方法是經過collections模塊的Iterable類型判斷：

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

　　在for循環裏，同時引用了兩個變量，在Python裏是很常見的，好比下面的代碼：

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

　　任何可迭代對象均可以做用於for循環，包括咱們自定義的數據類型，只要符合迭代條件，就可使用for循環。

列表生成式

　　列表生成式做爲Python編程的高級特性，能夠簡化很多代碼量。列表生成式（List Comprehensions）是Python內置的很是簡單卻強大的能夠用來建立list的生成式。

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

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

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

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

　　可是循環太繁瑣，而列表生成式則能夠用一行語句代替循環生成上面的list：

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

　　寫列表生成式時，把要生成的元素x * x放到前面，後面跟for循環，就能夠把list建立出來，for循環後面還能夠加上if判斷，這樣咱們就能夠篩選出僅偶數的平方：

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

　　列表生成式也可使用兩個變量來生成list：

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

　　把一個list中全部的字符串變成小寫：

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

　　列表生成式不是真正的語句，而是看起來像循環的表達式，這是將它歸爲循環語句的緣由。該功能很強大，但大多數狀況下，直接使用循環和條件語句也能完成。然而，列表生成式的程序十分簡潔，更加易讀。

　　下面來個例子：

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