函數語言程式設計

將業務邏輯細化，抽象，封裝成一個個功能函式，並藉助語言自帶的高階函式api，將整個業務流程轉化為函式之間的相互呼叫，這就是函數語言程式設計。
對比：將業務邏輯細化，抽象，封裝成一個個物件，並藉助語言，庫，元件，框架等，將整個業務流程轉化為物件之間的相互呼叫，這就是面向物件程式設計。

1. 函數語言程式設計的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許返回一個函式！

2. Python對函數語言程式設計提供部分支援。由於Python允許使用變數，因此，Python不是純函數語言程式設計語言。

高階函式

把函式作為引數傳入，這樣的函式稱為高階函式，函數語言程式設計就是指這種高度抽象的程式設計正規化。變數可以指向函式，函式名也是變數，函式名其實就是指向函式的變數！

map/reduce

1. map()函式接收兩個引數，一個是函式，一個是Iterable，map將傳入的函式（只寫函式名即可）依次作用到序列的每個元素，並把結果作為新的Iterator返回。map(函式，Iterable)
   reduce把一個函式作用在一個序列[x1, x2, x3, …]上，這個函式必須接收兩個引數，一個是函式，一個是序列。reduce把結果繼續和序列的下一個元素計算。使用reduce記得導包。reduce(函式，序列)

練習程式碼：

map() //對資料執行分批並行操作
reduce() //對操作所有返回值求結果

#str轉換為int的函式
def char2num
 
(s):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
def str2int(s):
    return reduce(lambda x,y:x*10+y,map(char2num,s))
print(str2int('13579'))

#上面的return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]也就是說,可以把{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5
 
, '6': 6, '7': 7, '8': 8, '9': 9}看成是一個字典，s是key，函式通過s引數查詢字典中的key，進而獲取value，返回value的值。

利用map()函式，把使用者輸入的不規範的英文名字，變為首字母大寫，其他小寫的規範名字。
# 輸入：['adam', 'LISA', 'barT']，輸出：['Adam', 'Lisa', 'Bart']

def normalize(name):
    return name[0].upper() + name.lower()[1:]
for n in map(normalize,['adam', 'LISA', 'barT']):  #iterator輸出需要藉助for迴圈
    print(n)

#請編寫一個prod()函式，可以接受一個list並利用reduce()求積
from functools import reduce

def fun(x,y):
    return x*y #計算方法
def prod(L):
    return reduce(fun, L) #reduce(lambda x,y:x*y,L)
list = [1,3,5]
print(prod(list))

 #str轉換為int的函式
from functools import reduce
def char2num(s):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
 # 也就是說,可以把{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}看成是一個字典，
 # s是key，函式通過s引數查詢字典中的key，進而獲取value，返回value的值。
def str2int(s):
    return reduce(lambda x,y:x*10+y,map(char2num,s))
print(str2int('13579'))

# 利用map和reduce編寫一個str2float函式，把字串'123.456'轉換成浮點數123.456：
from functools import reduce

def str2flost(s):
    def char2num(s):
        return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,}[s]
    return (reduce(lambda x,y:x*10+y,map(char2num, s.split('.')[0]))
                 + reduce(lambda x,y:x*10+y, map(char2num, s.split('.')[1])) / 10 ** len(s.split('.')[1]))
print(str2flost('123.456'))

'''
s.split('.')[0] -> 以'.'為分隔符,並取序列為0的項。

10 ** len(s.split('.')[1] ->由於後面拼接的小數部分，所以需要除以（10的小數位數的次方）
'''

filter（篩選器）

Python內建的filter()函式用於過濾序列。

1. 和map()類似，filter()也接收一個函式和一個序列。和map()不同的是，filter()把傳入的函式依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素。

2. filter（函式，序列） ->不滿足函式方法的序列（函式返回False）會被刪除，滿足的（True）將會保留。

3. filter()函式返回的是一個Iterator，也就是一個惰性序列，所以要強迫filter()完成計算結果，需要用list()函式獲得所有結果並返回list。

#用filter求素數
def _odd_iter(): #奇數生成器
    n = 1
    while True:
        n = n + 2
        yield n

def _not_divisible(n): #篩選函式,不能被1,3,5，...整除
    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) #構造新序列
#列印1000以內的素數
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

1. filter()的作用是從一個序列中篩出符合條件的元素。由於filter()使用了惰性計算，所以只有在取filter()結果的時候，才會真正篩選並每次返回下一個篩出的元素。

#回數是指從左向右讀和從右向左讀都是一樣的數，例如12321，909。請利用filter()濾掉非回數:
# -*- coding: utf-8 -*-
is_palindrome = lambda num: str(num) == str(num)[::-1] #步長為-1則從右往左第1個（最右一個為-1）開始

# 測試:
output = filter(is_palindrome, range(1, 1000))
print(list(output))

sorted

Python內建的sorted()函式就可以對list進行排序。用sorted()排序的關鍵在於實現一個對映函式。

1. sorted()函式也是一個高階函式，它可以接收一個key函式來實現自定義的排序，key指定的函式將作用於list的每一個元素上，並根據key函式返回的結果進行排序。

2. 預設情況下，對字串排序，是按照ASCII的大小比較的。

3. 要進行反向排序，不必改動key函式，可以傳入第三個引數reverse=True。

#請用sorted()對L列表分別按名字排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)] #並非鍵值對
'''
def by_name(L):
    return L[0]
print(sorted(L,key=by_name)) #注意key=函式名，而不是呼叫函式：TypeError: 'tuple' object is not callable
'''
#lambda
print(sorted(L,key = lambda x:x[0]))

#按成績排序
print(sorted(L,key=lambda x:x[1],reverse =True))#第三個引數實現反向排序，注意要寫在sorted方法裡

返回函式

高階函式除了可以接受函式作為引數外，還可以把函式作為結果值返回。一個函式可以返回一個計算結果，也可以返回一個函式。返回一個函式時，牢記該函式並未執行，返回函式中不要引用任何可能會變化的變數。

1. 當一個函式返回了一個函式後，其內部的區域性變數還被新函式引用。

2. 返回的函式並沒有立刻執行，而是直到呼叫了f()才執行。（f=外部函式）

3. 閉包：引用了自由變數的函式。

4. 返回閉包時牢記的一點就是：返回函式不要引用任何迴圈變數，或者後續會發生變化的變數。如果一定要引用迴圈變數怎麼辦？方法是再建立一個函式，用該函式的引數繫結迴圈變數當前的值，無論該迴圈變數後續如何更改，已繫結到函式引數的值不變。可利用lambda縮短程式碼。

def build(x, y):  #傳入引數
    return lambda: x * x + y * y
f =build(1,2) #不會直接出結果
print(f())

匿名函式

關鍵字lambda表示匿名函式，冒號前面的x表示函式引數。

1. 匿名函式有個限制，就是隻能有一個表示式，不用寫return，返回值就是該表示式的結果。

2. 用匿名函式有個好處，因為函式沒有名字，不必擔心函式名衝突。此外，匿名函式也是一個函式物件，也可以把匿名函式賦值給一個變數，再利用變數來呼叫該函式。f=lambda x:x*x

3. 同樣，也可以把匿名函式作為返回值返回。如：

def build(x, y):
    return lambda: x * x + y * y #引數(x,y)在函式中傳入
f =build(1,2)
print(f())

1. Python對匿名函式的支援有限，只有一些簡單的情況下可以使用匿名函式。

裝飾器

在程式碼執行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。

1. 函式物件有一個name屬性，可以拿到函式的名字。

2. 在面向物件（OOP）的設計模式中，decorator被稱為裝飾模式。OOP的裝飾模式需要通過繼承和組合來實現，而Python除了能支援OOP的decorator外，直接從語法層次支援decorator。Python的decorator可以用函式實現，也可以用類實現。

3. 本質上，decorator就是一個返回函式的高階函式。

#請編寫一個decorator，能在函式呼叫的前後打印出'begin call'和'end call'的日誌。
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)  #wrapper.__name__ = func.__name__
        def wrapper(*args, **kw):
            print(text)
            print('begin call')
            func(*args,**kw)
            print('end call')
        return wrapper #只返回函式名
    return decorator
@log("excute")
def now():
    print("2015-02-56")
now()

不是很理解，以後再補充。

偏函式

偏函式和數學意義上的偏函式不一樣，偏函式通過設定引數的預設值，可以降低函式呼叫的難度。

1. functools.partial就是幫助我們建立一個偏函式的，簡單總結functools.partial的作用就是，把一個函式的某些引數給固定住（也就是設定預設值），返回一個新的函式，呼叫這個新函式會更簡單。

2. 建立偏函式時，實際上可以接收函式物件、* args和 * *kw這3個引數。

3. 當函式的引數個數太多，需要簡化時，使用functools.partial可以建立一個新的函式，這個新函式可以固定住原函式的部分引數，從而在呼叫時更簡單。

#int()函式可以把字串轉換為整數，當僅傳入字串時，int()函式預設按十進位制轉換；
#int()函式還提供額外的base引數，預設值為10。如果傳入base引數，就可以做N進位制的轉換

import functools

int2 = functools.partial(int,base =2) #將二進位制轉換為十進位制
print(int2('1000'))

學習網站:www.liaoxuefeng.com