在 Python 中，代碼不是越多越好，而是越少越好。代碼不是越復(fù)雜越好，而是越簡單越好。
基于這一思想，我們來介紹 Python 中非常有用的高級特性，1 行代碼能實(shí)現(xiàn)的功能，決不寫 5 行代碼。請始終牢記，代碼越少，開發(fā)效率越高。
切片
取一個 list 或 tuple 的部分元素是非常常見的操作。比如，一個 list 如下：
x = ['0', '1', '2', '3', '4']
現(xiàn)在我我要取前三個元素怎么辦呢？
馬上就能想到的辦法：
>>> [x[0], x[1], x[2]]
['0', '1', '2']
稍微思考一下的辦法：
>>> r = []
>>> n = 3
>>> for i in range(n):
... r.append(x[i])
...
>>> r
['0', '1', '2']
看了一下 API 后的辦法：
>>> x[0:3]
['0', '1', '2']
對這種經(jīng)常取指定索引范圍的操作，用循環(huán)十分繁瑣，因此，Python 提供了切片（Slice）操作符，能大大簡化這種操作。
x[0:3]表示，從索引0開始取，直到索引3為止，但不包括索引3。即索引0，1，2，正好是 3 個元素。
如果第一個索引是0，還可以省略：
>>> x[:3]
['0', '1', '2']
也可以從索引 1 開始，取出 2 個元素出來：
>>> x[1:3]
['1', '2']
類似的，既然 Python 支持x[-1]取倒數(shù)第一個元素，那么它同樣支持倒數(shù)切片，試試：
>>> x[-2:]
['3', '4']
>>> L[-2:-1]
['3']
倒數(shù)第一個元素的索引是-1。
更酷炫的玩法
切片操作十分有用。我們先創(chuàng)建一個 0-99 的數(shù)列：
>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]
可以通過切片輕松取出某一段數(shù)列。比如前 10 個數(shù)：
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
后 10 個數(shù)：
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
前 11-20 個數(shù)：
>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
前 10 個數(shù)，每兩個取一個：
>>> L[:10:2]
[0, 2, 4, 6, 8]
所有數(shù)，每 5 個取一個：
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
甚至什么都不寫，只寫[:]就可以原樣復(fù)制一個 list：
>>> L[:]
[0, 1, 2, 3, ..., 99]
tuple 也是一種 list，唯一區(qū)別是 tuple 不可變。因此，tuple 也可以用切片操作，只是操作的結(jié)果仍是 tuple：
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
字符串'xxx'也可以看成是一種 list，每個元素就是一個字符。因此，字符串也可以用切片操作，只是操作結(jié)果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'
迭代
我們可以通過for循環(huán)來遍歷這個 list 或 tuple，這種遍歷我們稱為迭代（Iteration）。
在 Python 中，迭代是通過for ... in來完成的，而很多語言比如 java 語言，迭代 list 是通過下標(biāo)完成的，比如 Java 代碼：
for (i=0; i<list.length; i++) {
n = list[i];
}
可以看出，Python 的for循環(huán)抽象程度要高于 java 的for循環(huán)，因?yàn)?Python 的for循環(huán)不僅可以用在 list 或 tuple 上，還可以作用在其他可迭代對象上。
list 這種數(shù)據(jù)類型雖然有下標(biāo)，但很多其他數(shù)據(jù)類型是沒有下標(biāo)的，但是，只要是可迭代對象，無論有無下標(biāo)，都可以迭代，比如 dict 就可以迭代：
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
... print(key)
...
a
c
b
因?yàn)?dict 的存儲不是按照 list 的方式順序排列，所以，迭代出的結(jié)果順序很可能不一樣。
默認(rèn)情況下，dict 迭代的是 key。如果要迭代 value，可以用for value in d.values()，如果要同時迭代 key 和 value，可以用for k, v in d.items()。
由于字符串也是可迭代對象，因此，也可以作用于for循環(huán)：
>>> for ch in '123':
... print(ch)
...
1
2
3
看來在 Python 中有很多可以迭代的對象，可是我們該如何判斷一個對象是可迭代對象呢？
Python 也為我們提供了解決辦法，可以方法是通過 collections 模塊的 Iterable 類型判斷：
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整數(shù)是否可迭代
False
就剩一個小問題，如果要對 list 實(shí)現(xiàn)類似 Java 那樣的下標(biāo)循環(huán)怎么辦？
Python 內(nèi)置的enumerate函數(shù)可以把一個 list 變成索引 - 元素對，這樣就可以在for循環(huán)中同時迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']):
... print(i, value)
...
0 A
1 B
2 C
上面的for循環(huán)里，同時引用了兩個變量，在 Python 里是很常見的，比如下面的代碼：
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
... print(x, y)
...
1 1
2 4
3 9
列表生成式
列表生成式即 List Comprehensions，是 Python 內(nèi)置的非常簡單卻強(qiáng)大的可以用來創(chuàng)建 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]怎么做？方法一是循環(huán)：
>>> L = []
>>> for x in range(1, 11):
... L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
但是循環(huán)太繁瑣，而列表生成式則可以用一行語句代替循環(huán)生成上面的 list：
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
for 循環(huán)后面還可以加上 if 判斷，這樣我們就可以篩選出僅偶數(shù)的平方：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
還可以使用兩層循環(huán)，可以生成全排列：
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
for循環(huán)其實(shí)可以同時使用兩個甚至多個變量，比如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']
最后把一個 list 中所有的字符串變成小寫：
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
