1 高級(jí)特性

1.1 切片

取一個(gè)list或tuple的部分元素是非常常見(jiàn)的操作。

L = list(range(15))
#取索引為0~(N-1)個(gè)元素L[0:N]
print(L[0:10])
#如果第一個(gè)索引是0，還可以省略
print(L[:10])
#支持L[-1]取倒數(shù)第一個(gè)元素
print(L[-1])
#支持倒數(shù)切片
print(L[-10:])
#倒數(shù)第一個(gè)元素的索引是-1
print(L[-10:-1])
#跨步長(zhǎng)取數(shù)據(jù),前10個(gè)數(shù)，每?jī)蓚€(gè)取一個(gè)：
print(L[:10:2])
#所有數(shù)扛邑，每5個(gè)取一個(gè)
print(L[::5])
#原樣復(fù)制一個(gè)list
print(L[:])
#倒序輸出列表
print(L[::-1])

輸出結(jié)果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
14
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
[5, 6, 7, 8, 9, 10, 11, 12, 13]
[0, 2, 4, 6, 8]
[0, 5, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
[14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

1.2 迭代

在Python中，迭代是通過(guò)for ... in來(lái)完成的铐然。Python的for循環(huán)不僅可以用在list或tuple上蔬崩，還可以作用在其他可迭代對(duì)象上。
如何判斷一個(gè)對(duì)象是可迭代對(duì)象呢锦爵？方法是通過(guò)collections模塊的Iterable類型判斷：

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

1.2.1 字典的迭代：

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

字典默認(rèn)迭代的是key，如果要迭代value奥裸，可以用for value in d.values()险掀，如果要同時(shí)迭代key和value，可以用for k, v in d.items()湾宙。
注意：因?yàn)閐ict的存儲(chǔ)不是按照l(shuí)ist的方式順序排列樟氢，所以冈绊，迭代出的結(jié)果順序很可能不一樣。

1.2.2 列表或者字符串的迭代：

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

1.3 列表生成式

列表生成式即List Comprehensions埠啃，是Python內(nèi)置的非常簡(jiǎn)單卻強(qiáng)大的可以用來(lái)創(chuàng)建list的生成式死宣。
列舉幾個(gè)常用的列表生成式的例子：

>>> 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']

1.4生成器

通過(guò)列表生成式，我們可以直接創(chuàng)建一個(gè)列表碴开。但是毅该，受到內(nèi)存限制，列表容量肯定是有限的潦牛。而且眶掌，創(chuàng)建一個(gè)包含100萬(wàn)個(gè)元素的列表，不僅占用很大的存儲(chǔ)空間巴碗，如果我們僅僅需要訪問(wèn)前面幾個(gè)元素朴爬，那后面絕大多數(shù)元素占用的空間都白白浪費(fèi)了。

所以橡淆，如果列表元素可以按照某種算法推算出來(lái)召噩，那我們是否可以在循環(huán)的過(guò)程中不斷推算出后續(xù)的元素呢？這樣就不必創(chuàng)建完整的list逸爵，從而節(jié)省大量的空間具滴。在Python中，這種一邊循環(huán)一邊計(jì)算的機(jī)制痊银，稱為生成器：generator抵蚊。

1.4.1 簡(jiǎn)單創(chuàng)建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>

注意理解：generator保存的是算法致稀，每次調(diào)用next(g)冈闭，就計(jì)算出g的下一個(gè)元素的值，直到計(jì)算到最后一個(gè)元素抖单，沒(méi)有更多的元素時(shí)萎攒，拋出StopIteration的錯(cuò)誤。
然而這種不斷調(diào)用next(g)實(shí)在是太變態(tài)了矛绘，正確的方法是使用for循環(huán)耍休，因?yàn)間enerator也是可迭代對(duì)象。

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4

1.4.2 yield創(chuàng)建generator

如果一個(gè)函數(shù)定義中包含yield關(guān)鍵字货矮，那么這個(gè)函數(shù)就不再是一個(gè)普通函數(shù)羊精，而是一個(gè)generator:

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和函數(shù)的執(zhí)行流程不一樣。函數(shù)是順序執(zhí)行囚玫，遇到return語(yǔ)句或者最后一行函數(shù)語(yǔ)句就返回喧锦。而變成generator的函數(shù)读规，在每次調(diào)用next()的時(shí)候執(zhí)行，遇到y(tǒng)ield語(yǔ)句返回燃少，再次執(zhí)行時(shí)從上次返回的yield語(yǔ)句處繼續(xù)執(zhí)行束亏。

舉一個(gè)經(jīng)典的例子，使用generator打印楊輝三角：

# -*- coding: utf-8 -*-

def triangles():
    Y = [1]
    while True:
        yield Y
        Y = [1] + [Y[i] + Y[i + 1] for i in range(len(Y) - 1)] + [1]
    pass

n = 0
results = []
for t in triangles():
    print(t)
    results.append(t)
    n = n + 1
    if n == 10:
        break
if results == [
    [1],
    [1, 1],
    [1, 2, 1],
    [1, 3, 3, 1],
    [1, 4, 6, 4, 1],
    [1, 5, 10, 10, 5, 1],
    [1, 6, 15, 20, 15, 6, 1],
    [1, 7, 21, 35, 35, 21, 7, 1],
    [1, 8, 28, 56, 70, 56, 28, 8, 1],
    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
    print('測(cè)試通過(guò)!')
else:
    print('測(cè)試失敗!')

1.5迭代器

我們已經(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

小結(jié)
凡是可作用于for循環(huán)的對(duì)象都是Iterable類型越庇；
凡是可作用于next()函數(shù)的對(duì)象都是Iterator類型，它們表示一個(gè)惰性計(jì)算的序列奉狈；
集合數(shù)據(jù)類型如list卤唉、dict、str等是Iterable但不是Iterator仁期，不過(guò)可以通過(guò)iter()函數(shù)獲得一個(gè)Iterator對(duì)象桑驱；
Python的for循環(huán)本質(zhì)上就是通過(guò)不斷調(diào)用next()函數(shù)實(shí)現(xiàn)的。

2 函數(shù)式編程

2.1 高階函數(shù)

2.1.1 map/reduce

map()函數(shù)接收兩個(gè)參數(shù)跛蛋，一個(gè)是函數(shù)熬的，一個(gè)是Iterable，map將傳入的函數(shù)依次作用到序列的每個(gè)元素赊级，并把結(jié)果作為新的Iterator返回押框。用法比較簡(jiǎn)單，舉兩個(gè)簡(jiǎn)單例子：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

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)

舉個(gè)例子：

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

>>> reduce(fn, map(char2num, '13579'))
13579

2.1.2 filter

和map()類似晋被，filter()也接收一個(gè)函數(shù)和一個(gè)序列兑徘。和map()不同的是，filter()把傳入的函數(shù)依次作用于每個(gè)元素羡洛，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素挂脑。

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 結(jié)果: ['A', 'B', 'C']

2.1.3 sorted

按默認(rèn)排序

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

sorted()函數(shù)也是一個(gè)高階函數(shù)，它還可以接收一個(gè)key函數(shù)來(lái)實(shí)現(xiàn)自定義的排序，例如按絕對(duì)值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

2.2返回函數(shù)

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

//調(diào)用函數(shù)f時(shí)最域，才真正計(jì)算求和的結(jié)果：
>>> f()
25

在函數(shù)返回里，有一個(gè)特別要注意的地方是閉包锈麸。注意到返回的函數(shù)在其定義內(nèi)部引用了局部變量args镀脂，所以，當(dāng)一個(gè)函數(shù)返回了一個(gè)函數(shù)后忘伞，其內(nèi)部的局部變量還被新函數(shù)引用薄翅，所以，閉包用起來(lái)簡(jiǎn)單氓奈，實(shí)現(xiàn)起來(lái)可不容易翘魄。

另一個(gè)需要注意的問(wèn)題是，返回的函數(shù)并沒(méi)有立刻執(zhí)行舀奶，而是直到調(diào)用了f()才執(zhí)行暑竟。我們來(lái)看一個(gè)例子：

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

在上面的例子中，每次循環(huán)育勺，都創(chuàng)建了一個(gè)新的函數(shù)但荤，然后，把創(chuàng)建的3個(gè)函數(shù)都返回了涧至。
你可能認(rèn)為調(diào)用f1()腹躁，f2()和f3()結(jié)果應(yīng)該是1，4南蓬，9纺非，但實(shí)際結(jié)果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

全部都是9！原因就在于返回的函數(shù)引用了變量i赘方，但它并非立刻執(zhí)行烧颖。等到3個(gè)函數(shù)都返回時(shí)，它們所引用的變量i已經(jīng)變成了3蒜焊，因此最終結(jié)果為9倒信。
注意：返回閉包時(shí)牢記一點(diǎn)：返回函數(shù)不要引用任何循環(huán)變量，或者后續(xù)會(huì)發(fā)生變化的變量泳梆。
如果一定要引用循環(huán)變量怎么辦鳖悠？方法是再創(chuàng)建一個(gè)函數(shù)，用該函數(shù)的參數(shù)綁定循環(huán)變量當(dāng)前的值优妙，無(wú)論該循環(huán)變量后續(xù)如何更改乘综，已綁定到函數(shù)參數(shù)的值不變：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被執(zhí)行，因此i的當(dāng)前值被傳入f()
    return fs

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

2.3匿名函數(shù)

關(guān)鍵字lambda表示匿名函數(shù)套硼，冒號(hào)前面的x表示函數(shù)參數(shù)卡辰。匿名函數(shù)有個(gè)限制，就是只能有一個(gè)表達(dá)式，不用寫return九妈，返回值就是該表達(dá)式的結(jié)果反砌。舉兩個(gè)簡(jiǎn)單例子：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

def build(x, y):
    return lambda: x * x + y * y

2.4裝飾器

假設(shè)我們要增強(qiáng)某個(gè)函數(shù)比如now()函數(shù)的功能，比如萌朱，在函數(shù)調(diào)用前后自動(dòng)打印日志宴树，但又不希望修改now()函數(shù)的定義，這種在代碼運(yùn)行期間動(dòng)態(tài)增加功能的方式晶疼，稱之為“裝飾器”（Decorator）酒贬。
本質(zhì)上，decorator就是一個(gè)返回函數(shù)的高階函數(shù)翠霍。所以锭吨，我們要定義一個(gè)能打印日志的decorator，可以定義如下：

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

觀察上面的log寒匙，因?yàn)樗且粋€(gè)decorator零如，所以接受一個(gè)函數(shù)作為參數(shù)，并返回一個(gè)函數(shù)锄弱。我們要借助Python的@語(yǔ)法埠况，把decorator置于函數(shù)的定義處：

@log
def now():
    print('2015-3-25')

調(diào)用now()函數(shù)，不僅會(huì)運(yùn)行now()函數(shù)本身棵癣，還會(huì)在運(yùn)行now()函數(shù)前打印一行日志：

>>> now()
call now():
2015-3-25

2.5偏函數(shù)

我們知道在函數(shù)里面通過(guò)設(shè)定參數(shù)的默認(rèn)值辕翰，可以降低函數(shù)調(diào)用的難度。而偏函數(shù)也可以做到這一點(diǎn)狈谊。舉例如下：
int()函數(shù)可以把字符串轉(zhuǎn)換為整數(shù)喜命，當(dāng)僅傳入字符串時(shí)，int()函數(shù)默認(rèn)按十進(jìn)制轉(zhuǎn)換：

>>> int('12345')
12345

但int()函數(shù)還提供額外的base參數(shù)河劝，默認(rèn)值為10壁榕。如果傳入base參數(shù)，就可以做N進(jìn)制的轉(zhuǎn)換：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

我們還可以重新定義一個(gè)函數(shù)：

def int2(x, base=2):
    return int(x, base)

>>> int2('1000000')
64
>>> int2('1010101')
85

而使用偏函數(shù)達(dá)到這種設(shè)定參數(shù)默認(rèn)值的方式如下：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85