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

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

　　最近太忙啦。很多事情需要自己處理，感覺時間不夠用啊~~~~今后，博客更新時間可能會慢下來（但不能荒廢了學習，要學習就得進行總結，哪怕借鑒前輩的學習資料），因此，無論閑忙，總是要學會總結。哈哈，正所謂“人不為己，天誅地滅”嘛。嘿嘿，沒這么回事，說笑的……好像又扯遠了。OK，回歸正題，下面將回到Python先~~~

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

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

#賺錢版代碼
>>>n = 1
>>>L = []
>>>while n <= 99:
...    L.append(n)
...    n = n + 2
...
>>>print(L)        #好多money，但老板不一定會給噢
#略縮版代碼
>>>L= list(range(1,100,2))
>>>print(L)
#終極版代碼
>>>[x for x in range(1,100,2)]

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

切片

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

　　關於Python編程中的符號（比如冒號，逗號，括號……）都是英文版的【重要的事情說好多遍，因為自己平時編程也會時常出現這類錯誤】，否則程序編譯會有Error，而且這種類型的錯誤還不好發現。因此，細節決定高度~~~

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

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

　　注：如果第一個索引是0，可以省略：

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

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

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

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

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

　　tuple也是一種list，唯一區別是tuple不可變。因此，tuple也可以用切片操作，只是操作的結果仍是tuple：

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

　　字符串’xxx’也可以看成是一種list，每個元素就是一個字符。因此，字符串也可以用切片操作，只是操作結果仍是字符串：

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

　　Python沒有針對字符串的截取函數，只需要切片一個操作就可以完成，非常簡單。

　　Python的切片非常靈活，一行代碼就可以實現很多行循環才能完成的操作。

迭代

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

　　list這種數據類型雖然有下標，但很多其他數據類型是沒有下標的，但是，只要是可迭代對象，無論有無下標，都可以迭代，比如dict就可以迭代：

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

　　因為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

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

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

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

列表生成式

　　列表生成式作為Python編程的高級特性，可以簡化不少代碼量。列表生成式（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]

　　列表生成式也可以使用兩個變量來生成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']

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

　　下面來個例子：

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