函數式編程
函數是Python內建支持的一種封裝，通過把大段代碼拆成函數，通過一層一層的函數調用，把複雜任務分解成簡單的任務，這種分解稱之爲面向過程的程序設計。函數就是面向過程的程序設計的基本單元。
函數式編程——Functional Programming，雖然也可以歸結到面向過程的程序設計，但其思想更接近數學計算。
函數式編程是一種抽象程度很高的編程範式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之爲沒有副作用。而允許使用變量的程序設計語言，由於函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。
函數式編程的一個特點就是，允許把函數本身作爲參數傳入另一個函數，還允許返回一個函數！Python對函數式編程提供部分支持。由於Python允許使用變量，因此，Python不是純函數式編程語言。
一、高階函數Higher-order function
1.變量可以指向函數
以Python內置的求絕對值的函數abs()爲例，調用該函數用以下代碼：
a=abs
print(a(-10))2.函數名也是變量
函數名其實是指向函數的變量！對於abs()函數，可以把函數名abs看成變量，它指向一個可以計算絕對值的函數！
如果把abs指向其他對象：
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable把abs指向10後，就無法通過abs(-10)調用該函數了！因爲abs這個變量已經不指向求絕對值函數而是指向一個整數10！
注：由於abs函數實際上是定義在__builtin__模塊中的，所以要讓修改abs變量的指向在其它模塊也生效，要用__builtin__.abs = 10。
3.傳入函數
變量可以指向函數，函數的參數能接收變量，那麼一個函數就可以接收另一個函數作爲參數，這種函數就稱之爲高階函數。
簡單的高階函數：結果爲11
def add(x,y,f):
return f(x)+f(y)
m=add(-5,6,abs)
print(m)編寫高階函數，就是讓函數的參數能夠接收別的函數。
小結：把函數作爲參數傳入，這樣的函數稱爲高階函數，函數式編程就是指這種高度抽象的編程範式。
4.map/reduce函數
Python內建了map()和reduce()函數。
map()函數接收兩個參數，一個是函數，一個是Iterable可迭代對象，map將傳入的函數依次作用到序列的每個元素，並把結果作爲新的Iterator返回。
例如，函數f(x)=x²，把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：
用Python代碼實現：
def f(x):
return x**2
r = map(f,[1,2,3,4,5,6,7,8,9])
print(list(r))map()傳入的第一個參數是f，即函數對象本身。由於結果r是一個Iterator，Iterator是惰性序列，因此通過list()函數讓它把整個序列都計算出來並返回一個list。
map()作爲高階函數，它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x²，還可以計算任意複雜的函數，比如，把這個list所有數字轉爲字符串：
r2 =list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))reduce(f, [x1, x2, x3, x4]) = f( f( f(x1, x2), x3), x4)from functools import reduce
def add(x,y):
return x + y
r3 = reduce(add,[1,3,5,7,9])
print(r3)def fn(x,y):
return x * 10 + y
r4 = reduce(fn,[1,3,5,7,9])
print(r4)from functools import reduce
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
#[s]是key，函數通過s參數查找字典中的key，進而獲取value，返回value的值。
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return reduce(fn, map(char2num, s))def normalize(name):
return name.title()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)from functools import reduce
def prod(L):
def fn(x,y):
return x * y
return reduce(fn,L)
print('3 * 5 * 7 * 9 =', prod([3, 4, 5, 6]))def str2float(s):
def fn(x,y):
return x * 10 + y
n = s.index('.')
s1 = list(map(int,[x for x in s[:n]]))
s2 = list(map(int,[x for x in s[n+1:]]))
return reduce(fn,s1)+ reduce(fn,s2) / 10 ** len(s2)
print('str2float(\'123.456\') =', str2float('123.456'))n = s.index('.')
利用 index() 函數確定字符串 S 中 ‘.’的位置。
s1 = list(map(int,[x for x in s[:n]]))
s2 = list(map(int,[x for x in s[n+1:]]))
先利用切片把傳入的 str 分成以前以後兩個部分（根據小數點分成整數和浮點數，分別處理），然後再把切割好的 s 利用列表生成式變成單個數字字符，map() 函數再負責把 int 函數作用到截取的s的每個元素中去。
5.filter函數
Python內建的filter()函數用於過濾序列。
filter()接收一個函數和一個序列。把傳入的函數依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素。
刪掉偶數，只保留奇數
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 結果: [1, 5, 9, 15]def not_empty(s):
return s and s.strip()#移除字符串頭尾空字符
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 結果: ['A', 'B', 'C']注意：filter()函數返回的是一個Iterator，也就是一個惰性序列，所以要強迫filter()完成計算結果，需要用list()函數獲得所有結果並返回list。
PS：關於Lambda
fun = [(lambda n : i + n) for i in range(10)]
print fun[3](4)
print fun[4](4) fun = [(lambda n,m = i : m + n) for i in range(10)]
print fun[3](4)
print fun[4](4) 輸出爲7,8......m得到了外部的i值形成了閉包，fun [3](4) = lambda n,m=3:3+n n爲4
用filter求素數
計算素數的一個方法是埃氏篩法.
列出從2開始的所有自然數，構造一個序列：2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一個數2，它一定是素數，然後用2把序列的2的倍數篩掉：3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一個數3，它一定是素數，然後用3把序列的3的倍數篩掉：5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
def _odd_iter():#初始數列直接考慮奇數列，除2之外的偶數都不是素數
n = 1
while True:#數列生成器，不擔心沒有退出條件
n = n+2
yield n
def _not_divisible(n):#排除條件
return lambda x:x % n >0
def primes():
yield 2
it = _odd_iter()#初始數列，其爲無窮數列
while True:
n = next(it)
yield n
it = filter(_not_divisible(n),it) #filter()將it中的元素分別作用於參數爲n的_not_divisible函數，爲False的都刪除
for n in primes():#限定一個輸出範圍，否則無限輸出下去
if n<100:
print(n)
else:
break第一輪輸出爲yield 2，第二輪輸出爲循環第一步yield n 爲 3時，此時以n爲3的參數，對it進行元素篩選，能被3整除的元素都刪除，然後輸出第一個元yield n 爲5，再篩選能被5整除的元素，依次進行下去.......
練習：回數是指從左向右讀和從右向左讀都是一樣的數，例如12321，909。請利用filter()濾掉非回數：
def is_palindrome(n):
I,m = n,0
while I:
m = I%10+m*10
I = I//10
return (n==m)
output = filter(is_palindrome,range(0,1000))
print(list(output))小結：filter()的作用是從一個序列中篩出符合條件的元素。由於filter()使用了惰性計算，所以只有在取filter()結果的時候，纔會真正篩選並每次返回下一個篩出的元素。
6.sorted排序算法
Python內置的sorted()函數就可以對list進行排序：
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]sorted()函數也是一個高階函數，它還可以接收一個key函數來實現自定義的排序，例如按絕對值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]字符串排序，默認情況下，對字符串排序，是按照ASCII的大小比較的，由於'Z' < 'a'，結果，大寫字母Z會排在小寫字母a的前面：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']小結：sorted()也是一個高階函數。用sorted()排序的關鍵在於實現一個映射函數。
練習： 用一組tuple表示學生名字和成績：L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]請用sorted()對上述列表分別按名字和分數排序：
方法一：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
return t[0].lower()
def by_score(t):
return t[1]
L2 = sorted(L, key=by_name)
print(L2)
L3 = sorted(L, key=by_score,reverse=True)
print(L3)L列表中的每個元素都是一個元組，首先按名字排序，key作用與排序中列表裏的每一個元素，所以傳入by_name裏的參數t是一個元組，需要對元組的第一個元素進行排序，所以是t[0]。
方法二：
def by_name(t):
for i in t:
if isinstance(i,str):
return i.lower()
高階函數除了可以接受函數作爲參數外，還可以把函數作爲結果值返回。
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum調用lazy_sum()時，返回的並不是求和結果，而是求和函數：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>調用函數f時，才真正計算求和的結果：
>>> f()
25在函數lazy_sum中定義了函數sum，並且，內部函數sum可以引用外部函數lazy_sum的參數和局部變量，當lazy_sum返回函數sum時，相關參數和變量都保存在返回的函數中，這種程序結構稱爲“閉包（Closure）”。
調用lazy_sum()時，每次調用都會返回一個新的函數，調用結果互不影響，即使傳入相同的參數：
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False1.閉包
注意到返回的函數在其定義內部引用了局部變量args，所以，當一個函數返回了一個函數後，其內部的局部變量還被新函數引用，所以，閉包用起來簡單，實現起來可不容易。另一個需要注意的問題是，返回的函數並沒有立刻執行，而是直到調用了f()才執行
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()>>> f1()
9
>>> f2()
9
>>> f3()
9每次循環，都創建了一個新的函數，然後，把創建的3個函數都返回了。結果爲9的原因：返回的函數引用了變量i，但它並非立刻執行。等到3個函數都返回時，它們所引用的變量i已經變成了3，因此最終結果爲9。
返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者後續會發生變化的變量。
如果一定要引用循環變量，就再創建一個函數，用該函數的參數綁定循環變量當前的值，無論該循環變量後續如何更改，已綁定到函數參數的值不變：
def count():
def f(j):
return lambda :j*j
fs=[]
for i in range(1,4):
fs.append(f(i))
return fs
f1,f2,f3 = count()
print(f1())
print(f2())小結： 一個函數可以返回一個計算結果，也可以返回一個函數。返回一個函數時，牢記該函數並未執行，返回函數中不要引用任何可能會變化的變量
三、匿名函數
當我們在傳入函數時，有些時候，不需要顯式地定義函數，直接傳入匿名函數更方便。在Python中，對匿名函數提供了有限支持。
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]def f(x):
return x * x匿名函數也是一個函數對象，也可以把匿名函數賦值給一個變量，再利用變量來調用該函數：
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25def build(x, y):
return lambda: x * x + y * y小結：Python對匿名函數的支持有限，只有一些簡單的情況下可以使用匿名函數。
四、裝飾器假設我們要增強now()函數的功能，比如，在函數調用前後自動打印日誌，但又不希望修改now()函數的定義，在代碼運行期間動態增加功能的方式，稱之爲“裝飾器”（Decorator）。本質上，decorator就是一個返回函數的高階函數。
定義一個能打印日誌的decorator如下：def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper 函數log，是一個decorator，所以可以接受一個函數作爲參數，並返回一個函數。函數對象有一個__name__屬性，可以拿到函數的名字。
藉助Python的@語法，把decorator置於函數的定義處：
@log
def now():
print('2015-3-25')>>> now()
call now():
2015-3-25now = log(now)log()是一個decorator，返回一個函數，所以，原來的now()函數仍然存在，只是現在同名的now變量指向了新的函數wrapper()函數。
wrapper()函數的參數定義是(*args, **kw)，因此，wrapper()函數可以接受任意參數的調用。在wrapper()函數內，首先打印日誌，再緊接着調用原始函數。
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator@log('execute')
def now():
print('2015-3-25')>>> now()
execute now():
2015-3-25>>> now.__name__
'wrapper'不需要編寫wrapper.__name__ = func.__name__這樣的代碼，Python內置的functools.wraps就是幹這個事的，所以，一個完整的decorator的寫法如下：
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper>>> now.__name__
'now'import functools
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator練習：編寫一個decorator，能在函數調用的前後打印出'begin call'和'end call'的日誌。再思考一下能否寫出一個@log的decorator，使它可以同時支持
@log('execute') / @log
def f():
pass import functools
def log(text):
if isinstance(text,(int,str,float)):
def decorator(func):
@functools.wraps(func)
def wrappers(*args,**kw):
print('begin call %s %s():' % (text,func.__name__))
out = func(*args,**kw)
print('end call %s %s():' % (text,func.__name__))
return out
return wrappers
return decorator
else:
func = text
@functools.wraps(func)
def wrapper(*args,**kw):
print('begin call %s():' % func.__name__)
out = func(*args,**kw)
print('end call %s():' % func.__name__)
return out
return wrapperPython的functools模塊提供了很多有用的功能，其中一個就是偏函數（Partial function）。通過設定參數的默認值，可以降低函數調用的難度。偏函數也可以做到這一點。舉例如下：
int()函數可以把字符串轉換爲整數，當僅傳入字符串時，int()函數默認按十進制轉換：
>>> int('12345')
12345>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565def int2(x, base=2):
return int(x, base)>>> import functools
>>> int2 = functools.partial(int, base=2)創建偏函數時，實際上可以接收函數對象、*args和**kw這3個參數
max2 = functools.partial(max, 10)
max2(5, 6, 7)args = (10, 5, 6, 7)
max(*args)
