切片

取一個(gè)list（列表）或tuple（元組）的部分元素是非常常見的操作
Python提供了切片（Slice）操作符罪治，比如:

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3]
['Michael', 'Sarah', 'Tracy']
>>> L[:3]
['Michael', 'Sarah', 'Tracy']
>>> L[1:3]
['Sarah', 'Tracy']
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

切片操作十分有用丽声。我們創(chuàng)建一個(gè)0-99的數(shù)列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> L[:10:2]
[0, 2, 4, 6, 8]
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
>>> 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晒骇，每個(gè)元素就是一個(gè)字符霉撵。因此磺浙，字符串也可以用切片操作，只是操作結(jié)果仍是字符串：

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

在很多編程語言中徒坡，針對(duì)字符串提供了很多各種截取函數(shù)（例如撕氧，substring），其實(shí)目的就是對(duì)字符串切片喇完。Python沒有針對(duì)字符串的截取函數(shù)伦泥，只需要切片一個(gè)操作就可以完成，非常簡(jiǎn)單锦溪。

迭代

如果給定一個(gè)list或tuple不脯，我們可以通過for循環(huán)來遍歷這個(gè)list或tuple，這種遍歷我們稱為迭代（Iteration）海洼。

在Python中跨新，迭代是通過for ... in來完成的富腊，而很多語言比如C或者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)镻ython的for循環(huán)不僅可以用在list或tuple上，還可以作用在其他可迭代對(duì)象上民假。

list這種數(shù)據(jù)類型雖然有下標(biāo)浮入，但很多其他數(shù)據(jù)類型是沒有下標(biāo)的，但是羊异，只要是可迭代對(duì)象事秀，無論有無下標(biāo)，都可以迭代野舶，比如dict就可以迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

因?yàn)閐ict的存儲(chǔ)不是按照list的方式順序排列易迹，所以，迭代出的結(jié)果順序很可能不一樣平道。

默認(rèn)情況下睹欲，dict迭代的是key。如果要迭代value一屋，可以用for value in d.values()窘疮，如果要同時(shí)迭代key和value，可以用for k, v in d.items()冀墨。

由于字符串也是可迭代對(duì)象闸衫，因此，也可以作用于for循環(huán)：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

所以诽嘉，當(dāng)我們使用for循環(huán)時(shí)蔚出，只要作用于一個(gè)可迭代對(duì)象疫蔓，for循環(huán)就可以正常運(yùn)行，而我們不太關(guān)心該對(duì)象究竟是list還是其他數(shù)據(jù)類型身冬。

那么衅胀，如何判斷一個(gè)對(duì)象是可迭代對(duì)象呢？方法是通過collections模塊的Iterable類型判斷：

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

最后一個(gè)小問題酥筝，如果要對(duì)list實(shí)現(xiàn)類似Java那樣的下標(biāo)循環(huán)怎么辦滚躯？Python內(nèi)置的enumerate函數(shù)可以把一個(gè)list變成索引-元素對(duì)，這樣就可以在for循環(huán)中同時(shí)迭代索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循環(huán)里嘿歌，同時(shí)引用了兩個(gè)變量掸掏，在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)置的非常簡(jiǎn)單卻強(qiáng)大的可以用來創(chuàng)建list的生成式丧凤。

舉個(gè)例子，要生成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]
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [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 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

運(yùn)用列表生成式步脓，可以寫出非常簡(jiǎn)潔的代碼愿待。例如，列出當(dāng)前目錄下的所有文件和目錄名靴患，可以通過一行代碼實(shí)現(xiàn)：

>>> import os # 導(dǎo)入os模塊仍侥，模塊的概念后面講到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目錄
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'Xcode']

for循環(huán)其實(shí)可以同時(shí)使用兩個(gè)甚至多個(gè)變量，比如dict的items()可以同時(shí)迭代key和value：

因此鸳君，列表生成式也可以使用兩個(gè)變量來生成list：

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

最后把一個(gè)list中所有的字符串變成小寫：

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

生成器

通過列表生成式农渊，我們可以直接創(chuàng)建一個(gè)列表。但是或颊，受到內(nèi)存限制砸紊，列表容量肯定是有限的。而且囱挑，創(chuàng)建一個(gè)包含100萬個(gè)元素的列表醉顽，不僅占用很大的存儲(chǔ)空間，如果我們僅僅需要訪問前面幾個(gè)元素看铆，那后面絕大多數(shù)元素占用的空間都白白浪費(fèi)了徽鼎。

所以，如果列表元素可以按照某種算法推算出來弹惦，那我們是否可以在循環(huán)的過程中不斷推算出后續(xù)的元素呢否淤？這樣就不必創(chuàng)建完整的list，從而節(jié)省大量的空間棠隐。在Python中石抡，這種一邊循環(huán)一邊計(jì)算的機(jī)制，稱為生成器：generator助泽。

要?jiǎng)?chuàng)建一個(gè)generator啰扛，有很多種方法嚎京。第一種方法很簡(jiǎn)單，只要把一個(gè)列表生成式的[]改成()隐解，就創(chuàng)建了一個(gè)generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

創(chuàng)建L和g的區(qū)別僅在于最外層的[]和()鞍帝，L是一個(gè)list，而g是一個(gè)generator煞茫。

generator保存的是算法帕涌，每次調(diào)用next(g)，就計(jì)算出g的下一個(gè)元素的值续徽，直到計(jì)算到最后一個(gè)元素蚓曼，沒有更多的元素時(shí)，拋出StopIteration的錯(cuò)誤钦扭。

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

所以纫版，我們創(chuàng)建了一個(gè)generator后，基本上永遠(yuǎn)不會(huì)調(diào)用next()客情，而是通過for循環(huán)來迭代它其弊，并且不需要關(guān)心StopIteration的錯(cuò)誤。

generator非常強(qiáng)大裹匙。如果推算的算法比較復(fù)雜瑞凑，用類似列表生成式的for循環(huán)無法實(shí)現(xiàn)的時(shí)候末秃，還可以用函數(shù)來實(shí)現(xiàn)概页。

比如，著名的斐波拉契數(shù)列（Fibonacci）练慕，除第一個(gè)和第二個(gè)數(shù)外惰匙，任意一個(gè)數(shù)都可由前兩個(gè)數(shù)相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契數(shù)列用列表生成式寫不出來，但是铃将，用函數(shù)把它打印出來卻很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意项鬼，賦值語句：

a, b = b, a + b

相當(dāng)于：

t = (b, a + b) # t是一個(gè)tuple
a = t[0]
b = t[1]

但不必顯式寫出臨時(shí)變量t就可以賦值。

上面的函數(shù)可以輸出斐波那契數(shù)列的前N個(gè)數(shù)：

>>> fib(6)
1
1
2
3
5
8
'done'

仔細(xì)觀察劲阎，可以看出绘盟，fib函數(shù)實(shí)際上是定義了斐波拉契數(shù)列的推算規(guī)則，可以從第一個(gè)元素開始悯仙，推算出后續(xù)任意的元素龄毡，這種邏輯其實(shí)非常類似generator。

也就是說锡垄，上面的函數(shù)和generator僅一步之遙沦零。要把fib函數(shù)變成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
    return 'done'

這就是定義generator的另一種方法货岭。如果一個(gè)函數(shù)定義中包含yield關(guān)鍵字路操，那么這個(gè)函數(shù)就不再是一個(gè)普通函數(shù)疾渴，而是一個(gè)generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

這里，最難理解的就是generator和函數(shù)的執(zhí)行流程不一樣屯仗。函數(shù)是順序執(zhí)行搞坝，遇到return語句或者最后一行函數(shù)語句就返回。而變成generator的函數(shù)魁袜，在每次調(diào)用next()的時(shí)候執(zhí)行瞄沙，遇到y(tǒng)ield語句返回，再次執(zhí)行時(shí)從上次返回的yield語句處繼續(xù)執(zhí)行慌核。

舉個(gè)簡(jiǎn)單的例子距境，定義一個(gè)generator，依次返回?cái)?shù)字1垮卓，3垫桂，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

調(diào)用該generator時(shí)，首先要生成一個(gè)generator對(duì)象粟按，然后用next()函數(shù)不斷獲得下一個(gè)返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

可以看到诬滩，odd不是普通函數(shù)，而是generator灭将，在執(zhí)行過程中疼鸟，遇到y(tǒng)ield就中斷，下次又繼續(xù)執(zhí)行庙曙。執(zhí)行3次yield后空镜，已經(jīng)沒有yield可以執(zhí)行了，所以捌朴，第4次調(diào)用next(o)就報(bào)錯(cuò)吴攒。

回到fib的例子，我們?cè)谘h(huán)過程中不斷調(diào)用yield砂蔽，就會(huì)不斷中斷洼怔。當(dāng)然要給循環(huán)設(shè)置一個(gè)條件來退出循環(huán)，不然就會(huì)產(chǎn)生一個(gè)無限數(shù)列出來左驾。

同樣的镣隶，把函數(shù)改成generator后，我們基本上從來不會(huì)用next()來獲取下一個(gè)返回值诡右，而是直接使用for循環(huán)來迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for循環(huán)調(diào)用generator時(shí)安岂，發(fā)現(xiàn)拿不到generator的return語句的返回值。如果想要拿到返回值稻爬，必須捕獲StopIteration錯(cuò)誤嗜闻，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

迭代器

我們已經(jīng)知道，可以直接作用于for循環(huán)的數(shù)據(jù)類型有以下幾種：

一類是集合數(shù)據(jù)類型桅锄，如list琉雳、tuple样眠、dict、set翠肘、str等檐束；

一類是generator，包括生成器和帶yield的generator function束倍。

這些可以直接作用于for循環(huán)的對(duì)象統(tǒng)稱為可迭代對(duì)象：Iterable被丧。

可以使用isinstance()判斷一個(gè)對(duì)象是否是Iterable對(duì)象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用于for循環(huán)，還可以被next()函數(shù)不斷調(diào)用并返回下一個(gè)值绪妹，直到最后拋出StopIteration錯(cuò)誤表示無法繼續(xù)返回下一個(gè)值了甥桂。

可以被next()函數(shù)調(diào)用并不斷返回下一個(gè)值的對(duì)象稱為迭代器：Iterator。

可以使用isinstance()判斷一個(gè)對(duì)象是否是Iterator對(duì)象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator對(duì)象邮旷，但list黄选、dict、str雖然是Iterable婶肩，卻不是Iterator办陷。

把list、dict律歼、str等Iterable變成Iterator可以使用iter()函數(shù)：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能會(huì)問民镜，為什么list、dict险毁、str等數(shù)據(jù)類型不是Iterator制圈？

這是因?yàn)镻ython的Iterator對(duì)象表示的是一個(gè)數(shù)據(jù)流，Iterator對(duì)象可以被next()函數(shù)調(diào)用并不斷返回下一個(gè)數(shù)據(jù)辱揭，直到?jīng)]有數(shù)據(jù)時(shí)拋出StopIteration錯(cuò)誤离唐。可以把這個(gè)數(shù)據(jù)流看做是一個(gè)有序序列问窃，但我們卻不能提前知道序列的長(zhǎng)度，只能不斷通過next()函數(shù)實(shí)現(xiàn)按需計(jì)算下一個(gè)數(shù)據(jù)完沪，所以Iterator的計(jì)算是惰性的域庇，只有在需要返回下一個(gè)數(shù)據(jù)時(shí)它才會(huì)計(jì)算。

Iterator甚至可以表示一個(gè)無限大的數(shù)據(jù)流覆积，例如全體自然數(shù)听皿。而使用list是永遠(yuǎn)不可能存儲(chǔ)全體自然數(shù)的。

小結(jié)

凡是可作用于for循環(huán)的對(duì)象都是Iterable類型宽档；

凡是可作用于next()函數(shù)的對(duì)象都是Iterator類型尉姨，它們表示一個(gè)惰性計(jì)算的序列；

集合數(shù)據(jù)類型如list吗冤、dict又厉、str等是Iterable但不是Iterator九府，不過可以通過iter()函數(shù)獲得一個(gè)Iterator對(duì)象。

Python的for循環(huán)本質(zhì)上就是通過不斷調(diào)用next()函數(shù)實(shí)現(xiàn)的覆致，例如：

for x in [1, 2, 3, 4, 5]:
    pass

實(shí)際上完全等價(jià)于：

# 首先獲得Iterator對(duì)象:
it = iter([1, 2, 3, 4, 5])
# 循環(huán):
while True:
    try:
        # 獲得下一個(gè)值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循環(huán)
        break

函數(shù)式編程

• 高階函數(shù)
  -map():接收兩個(gè)參數(shù)侄旬，一個(gè)是函數(shù)，一個(gè)是Iterable煌妈，map將傳入的函數(shù)依次作用到序列的每個(gè)元素儡羔，并把結(jié)果作為新的Iterator返回。
  -reduce:把一個(gè)函數(shù)作用在一個(gè)序列[x1, x2, x3, ...]上璧诵，這個(gè)函數(shù)必須接收兩個(gè)參數(shù)汰蜘，reduce把結(jié)果繼續(xù)和序列的下一個(gè)元素做累積計(jì)算晌柬，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

-filter():filter()也接收一個(gè)函數(shù)和一個(gè)序列或油。和map()不同的是，filter()把傳入的函數(shù)依次作用于每個(gè)元素味悄，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素澈缺。
-sorted:排序

• 裝飾器
  假設(shè)我們要增強(qiáng)一函數(shù)的功能坪创，比如，在函數(shù)調(diào)用前后自動(dòng)打印日志姐赡，但又不希望修改函數(shù)的定義莱预，這種在代碼運(yùn)行期間動(dòng)態(tài)增加功能的方式，稱之為“裝飾器”（Decorator）项滑。
• 偏函數(shù)
  當(dāng)函數(shù)的參數(shù)個(gè)數(shù)太多依沮，需要簡(jiǎn)化時(shí)，使用functools.partial可以創(chuàng)建一個(gè)新的函數(shù)枪狂，這個(gè)新函數(shù)可以固定住原函數(shù)的部分參數(shù)危喉，從而在調(diào)用時(shí)更簡(jiǎn)單。

面向?qū)ο缶幊?/h3>

• __slots__:定義class的時(shí)候州疾，定義一個(gè)特殊的slots變量辜限，來限制該class實(shí)例能添加的屬性：
• property:負(fù)責(zé)把一個(gè)方法變成屬性調(diào)用的
• mixIn:給一個(gè)類增加多個(gè)功能，這樣严蓖，在設(shè)計(jì)類的時(shí)候薄嫡，我們優(yōu)先考慮通過多重繼承來組合多個(gè)MixIn的功能，而不是設(shè)計(jì)多層次的復(fù)雜的繼承關(guān)系颗胡。
• ``