Python学习笔记（五），,目录：　　一.高阶函

Python学习笔记（五），,目录：　　一.高阶函

目录：

　　一.高阶函数

　　二.返回函数

　　三.匿名函数

　　四.偏函数

一.高阶函数

高阶函数英文叫Higher - order function.

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个简单的高阶函数:

def add(x, y, f):    return f(x) + f(y)

当我们调用add(-5,6,abs)时，参数x,y,f,分别接收-5,6，abs。

map/reduce

Python内建了map()和reduce()函数。

map:

map()函数接收两个参数，一个是函数，一个是Iterable,map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

举例说明：比如我们有一个函数f(x) = x²,要把这个函数作用在一个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, 16, 25, 36, 49, 64, 81]

map传入的参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

reduce:

reduce把一个函数作用在一个序列[x1,x2,x3,x4....]上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果是：

reduce(f, [x1, x2, x3, x4]) = 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

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

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

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> from functools import reduce>>> def fn(x, y):...     return x * 10 + y...>>> def char2num(s):...     digits = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}...     return digits[s]...>>> reduce(fn, map(char2num, ‘13579‘))13579

整理成一个str2int的函数就是：

from functools import reduceDIGITS = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}def str2int(s):    def fn(x, y):        return x * 10 + y    def char2num(s):        return DIGITS[s]    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

from functools import reduceDIGITS = {‘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))

filter

Python内建的filter()函数用于过滤序列。和map()类似，filter()也接受一个函数和一个序列。和map()不同的是，filter()把传入的元素依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如：在一个list中，删掉偶数，只保留奇数：

def is_odd(n):    return n%2 == 1list(filter(is_odd, [1,2,4,5,6,9,10,15]))

注意到filter()函数返回的是一个Iterator,也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

用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, ...

取新序列的第一个数5，然后用5把序列的5的倍数筛掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不断筛下去，就可以得到所有的素数。

用Python来实现这个算法，可以先构造一个从3开始的奇数序列：

def _odd_iter():     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) # 构造新序列

这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。

由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件：

for n in primes():    if n < 1000:        print(n)    else:        break

sorted

排序算法

Python内置的sorted()函数就可以对List进行排序：

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

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

二.返回函数

函数作为返回值

实现一个可变参数的求和：

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时，相关参数和变量都保存在返回的函数中，这种称为“闭包"的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)>>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> f1==f2False

f1()和f2()的调用结果互不影响。

闭包

注意到返回的函数在其定义内部引用了局部变量args,所以，当一个函数返回了一个函数后，其内部的局部变量还是被新函数引用。

另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。

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

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。

你可能认为调用f1(),f2(),f3()结果应该是1,4,9，但实际结果是：

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

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为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

三.匿名函数

例：

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

匿名函数lambda x: x*x实际上就是：

def f(x):

　　return x*x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

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

同样，也可以把匿名函数作为返回值返回，比如：

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

四.偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数。

>>>import functools>>>int2 = functools.partial(int, base=2)>>>int2(‘1000000‘)64

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

Python学习笔记（五）