• 函數語言程式設計

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

• 高階函式

既然變數可以指向函式，函式的引數能接收變數，那麼一個函式就可以接收另一個函式作為引數，這種函式就是高階函式。

• map()和reduce()

map()函式接收兩個引數，一個是函式，一個是序列，map將傳入的函式一次作用到序列的每個元素，並且把結果作為新的list返回。

比如，把這個list所有數字轉為字串：

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

 reduce()函式

reduce把一個函式作用在一個序列[x1, x2, x3...]上，這個函式必須接收兩個引數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：

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

比方說對一個序列求和，就可以用reduce實現：

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

這個例子本身沒多大用處，但是，如果考慮到字串str

>>> def fn(x, y):
...     return x * 10 + y
...
>>> 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]
...
>>> reduce(fn, map(char2num, '13579'))
13579

這個函式是完成將字元轉換為數字的功能，用到了dict和陣列的功能，其中你可以把 {'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):
	name=name[0].upper()+name[1:].lower()
	return name

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print L2

• filter()函式

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

把一個序列中的空字串刪掉，可以這麼寫：

def not_empty(s):
    return s and s.strip()
#strip()可以去除首位的空格
#strip('0')可以去除首位的0

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

練習！！！！！！！！！！！！！！！！！！！！！！！！！！！

用filter()刪除1~100的素數。 

import math
L = range(1, 101)
def delprimenum(str):
	if str == 1:
		return str
	for i in range(2,int(math.sqrt(str)+1)):
		if str % 1 == 0:
			return str

print filter(delprimenum, L)

• sorted()函式

Python內建的sorted()函式就可以對list進行排序：

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

 關於sorted函式的引數根據Python官方文件

sorted(iterable[,cmp,[,key[,reverse=True]]])
作用：返回一個經過排序的列表。
第一個引數是一個iterable，返回值是一個對iterable中元素進行排序後的列表(list)。
可選的引數有三個，cmp、key和reverse。
1)cmp指定一個定製的比較函式，這個函式接收兩個引數（iterable的元素），如果第一個引數小於第二個引數，返回一個負數；如果第一個引數等於第二個引數，返回零；如果第一個引數大於第二個引數，返回一個正數。預設值為None。
2)key指定一個接收一個引數的函式，這個函式用於從每個元素中提取一個用於比較的關鍵字。預設值為None。
3)reverse是一個布林值。如果設定為True，列表元素將被倒序排列。
key引數的值應該是一個函式，這個函式接收一個引數並且返回一個用於比較的關鍵字。對複雜物件的比較通常是使用物件的切片作為關鍵字。例如：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) #按年齡排序

此外，sorted()函式也是一個高階函式，它還可以接收一個比較函式來實現自定義的排序。比如，如果要倒序排序，我們就可以自定義一個reversed_cmp函式：

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

傳入自定義的比較函式reversed_cmp，就可以實現倒序排序：

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

• 返回函式

函式作為返回值

高階函式除了可以接受函式作為引數外，還可以把函式作為結果值返回。

我們來實現一個可變引數的求和。通常情況下，求和的函式是這樣定義的：

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

但是，如果不需要立刻求和，而是在後面的程式碼中，根據需要再計算怎麼辦？可以不返回求和的結果，而是返回求和的函式！

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 sum at 0x10452f668>

呼叫函式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
False

f1()和f2()的呼叫結果互不影響。

關於閉包檢視部落格返回函式一章

返回閉包時牢記的一點就是：返回函式不要引用任何迴圈變數，或者後續會發生變化的變數。

• 匿名函式

關鍵字lambda表示匿名函式，冒號前的x，y表示函式引數，例如

lambda x: x * x實際上就是

def f(x):

      return x*x

匿名函式只能有一個表示式，不用寫return，返回值就是該表示式的結果

• 裝飾器

在程式碼執行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。接受函式作為引數並返回一個函式。

關於@

@修飾符  　　‘@’符號用作函式修飾符是python2.4新增加的功能，修飾符必須出現在函式定義前一行，不允許和函式定義在同一行。也就是說＠A def f(): 是非法的。 只可以在模組或類定義層內對函式進行修飾，不允許修修飾一個類。一個修飾符就是一個函式，它將被修飾的函式做為引數，並返回修飾後的同名函式或其它可呼叫的東西。

　　本質上講，裝飾符@類似於回撥函式，把其它的函式（暫且稱為目的引數）作為自己的入參，在目的函式執行前，執行一些自己的操作，比如：計數、列印一些提示資訊等，然後返回目的函式。下面列舉一個簡單的例子。

import time

def time(func):
    print(time.ctime())
    return func()

@time  # 從這裡可以看出@time 等價於 time(xxx()),但是這種寫法你得考慮python程式碼的執行順序
def xxx():
    print('Hello world!')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

執行結果：
Wed Jul 26 23:01:21 2017
Hello world!

練習！！！！！！！！！！！！！！！！！！！！！！！

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

def log(func):
	def wrapper():
		print 'begin call'
		func()
		print 'end call'
	return wrapper

@log
def myage():
	print '21'

myage()

2、再思考一下能否寫出一個@log的decorator，使它既支援：

@log
def f():
    pass

又支援：

@log('execute')
def f():
    pass

程式碼！！！！！關於decorator需要好好看看 

import functools

def log(arg):
	if callable(arg):
		# @log模式
		func = arg
		@functools.wraps(func)
		def wrapper(*args, **kw):
			print 'call %s(): ' %func.__name__
			func(*args, **kw) #相當於返回func
		return wrapper
	else:
		# @log('arg')模式
		def decorator(func):
			def wrapper(*args, **kw):
				print '%s %s(): ' %(arg, func.__name__)
				func(*args, **kw)
			return wrapper
		return decorator

@log
def now():
	print 'Saikikky'

@log('Hi')
def next():
	print 'Saikikky'


now()
next()

•  偏函式

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