Python基礎——4高階函數

高階函數

函數自己可用變量指向，把變量當作函數參數的函數成爲高階函數

map and reduce

map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次做用到序列的每一個元素，並把結果做爲新的Iterator返回。

舉例說明，好比咱們有一個函數f(x)=x2，要把這個函數做用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就能夠用map()實現以下：

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

map()傳入的第一個參數是f，即函數對象自己。因爲結果r是一個Iterator，Iterator是惰性序列，所以經過list()函數讓它把整個序列都計算出來並返回一個list。

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

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

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

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

25

filter

根據函數的返回結果True or False對list等進行篩選，結果是一個Iterator

例：選出偶素

def odd()
    n = 1
    yield n
    n = n + 1
def chu()
    return lambda x : x%2 > 0  # lambda關鍵字，匿名函數
def oushu()
    n = odd()
    while True:
    t = next(n)
    output = filter(chu,n)
print(list(output))

sorted

排序函數

 L=[15,-5,6,-89,100]

 sorted(L)

 [-89,-5,6,15,100]

 sorted(L,key=abs)

 [-5,6,15,-89,100]

sorted(L,key=abs, reverse = True)

[100,-89,15,6,-5]

字符串排序是根據ASCLL碼大小排序

返回函數

return 返回一個函數值

當把函數計算結果不是當即返回，在調用的時候返回，可用到返回函數。

返回函數裏邊不要有循環變量

例子：

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

若是用到循環變量，就把變量當作參數傳進去：

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)馬上被執行，所以i的當前值被傳入f()
    return fs

計數器函數：

def createCounter :
    a = 0
    def counter:
        nonlocal a    #nonlocal關鍵字用來在函數或其餘做用域中使用外層(非全局)變量。
        a = a + 1
        return a
    return counter

匿名函數

能夠當作函數返回，能夠用變量指向函數

f = lambda x: x*x
def lambda(x):
   return x*x

裝飾器（修飾函數）

修飾函數能夠看作是返回函數的一種，目的是在函數的執行前或函數執行後先進行相關的處理操做(函數運行期間動態添加功能的成爲裝飾器)，添加在定義函數的前面，實現裝飾做用。

例如：

計算函數的執行時間

import time funtools
def log(text)
def decorator(fnc):
    @functools.wraps(fnc)
        def wrapper(*args,**kw):
           start  = time.time()
            func = fnc(*args,**kw)
            end = time.time()
            print(%s : %s excuted in %s ms %(text,func_name_,(start - end)*1000))
            return func
        return wrapper
    return decorator

偏函數

固定住某些函數的參數，使函數調用更加方便

例子：

import functools
int 2 = functools.partial(int,base = 2)
max 2 = functools.partial(max,10)
max 2(5,6,7) = 10