python学习（4）——高阶函数

高阶函数
在学习高阶函数之前，我们需要知道：变量可以指向函数，函数本身也可以赋值给变量。如：

通常，我们所指的高阶函数是：把函数作为参数传给另一个函数

下面介绍几个python内建的高阶函数：

map函数

map函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
例如：传入一个序列，输出它每一项的平方

In [1]: li = [1,2,3]

In [2]: print map(str,li)
['1', '2', '3']

reduce函数

reduce把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
例：求一个序列的和

In [3]: def add(x , y):
   ...:     return x+y
   ...: 

In [4]: print reduce(add,range(1,6))
15

filter函数

filter函数可以用来实现过滤
filter() 也接收一个函数和一个序列。把传入的函数依次作用于每个元素,然后根据返回值是 True，还是 False 决定保留还是丢弃该元素。
例：用filter过滤1-100的质数

def zhishu(n):
    if n > 1:
        for i in range(2, n / 2 + 1):
            if n % i == 0:
                return False
        return True
print filter(zhishu, range(1, 101))

运行结果：

sorted函数

sorted()可以实现对list的排序，它还可以接收一个比较函数来实现自定义的排序。
排序的核心是比较两个元素的大小。通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
例如：有一个元组，存了一序列数字，可以用它实现从小到大的排序

In [1]: t = (1,17,5,44,16,38)

In [2]: sorted(t)
Out[2]: [1, 5, 16, 17, 38, 44]

如果要实现从大到小的排序，我们需要重新定义它的规定：

In [3]: def reversed_cmp(x,y):
   ...:     if x>y:
   ...:         return -1
   ...:     elif x<y:
   ...:         return 1
   ...:     else:
   ...:         return 0
   ...:     

In [4]: sorted(t,reversed_cmp)
Out[4]: [44, 38, 17, 16, 5, 1]

它对字符串也可以排序，排序时是根据首字母的ASCII进行排列的。
如果想要忽略大小写，可以定义函数如下：

ll = ['aa', 'hello', 'Happy', 'ABC']
print sorted(ll)

# 忽略大小写
def ig(x, y):
    l1 = x.lower()
    l2 = y.lower()
    if l1 < l2:
        return -1
    elif l1 > l2:
        return 1
    else:
        return 0
print sorted(ll,ig)

函数作为返回值（闭包）

高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
例如：

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

f1,f2,f3 = count()
print f1
print f1()
print f2()
print f3()

返回的结果是函数，输出时如果不写成f1()，而是f，返回的则是地址

匿名函数

匿名函数的优势:
1). 匿名函数不需要函数名，可以避免函数名的冲突；
2). 匿名函数可以跳过给函数分配栈空间；
python 使用 lambda 来创建匿名函数。
——lambda只是一个表达式，而不是一个代码块。
例如，我们来看一看平常和用匿名函数写返回1-10的平方是怎样实现的

def pow1(x):
    return x*x
print map(pow1,range(1,11))

#匿名函数
print map(lambda x:x*x, range(1,11))

关键字 lambda 表示匿名函数,冒号前面的 x 表示函数参数，后面表示返回的值，匿名函数不用return。

• 匿名函数可以赋值给一个变量

In [1]: f = lambda :1

In [2]: print f()
1

• 匿名函数传递必选参数和默认参数

In [3]: f = lambda x,y=2:x**y

In [4]: print f(2,3)
8

In [5]: print f(2)
4

• 匿名函数传递可变参数

In [6]: f = lambda *x:map(lambda x:x+x,x)

In [7]: print f(1,2,3,4)
[2, 4, 6, 8]

• 匿名函数传递关键字参数

In [8]: f = lambda  **kwargs:kwargs.items()

In [9]: print f(name="fentiao",age=5)
[('age', 5), ('name', 'fentiao')]

• 练习:利用匿名函数和字典重新编辑计算器

#!/usr/bin/env python
# coding:utf-8
from __future__ import division  # 除法
_author_ = "xj"

num1 = input("num1:")
operate = raw_input("operate:")
num2 = input("num2:")
dic = {"+": lambda num1, num2: num1 + num2, 
       "-": lambda num1, num2: num1 - num2, 
       "*": lambda num1, num2: num1 * num2,
       "/": lambda num1, num2: num1 / num2}
if operate in dic.keys():
    print dic[operate](num1, num2)
else:
    print "wrong! use(+ - * /)"

装饰器

装饰器：用来装饰函数的一个函数
它的目标是添加功能，装饰函数，而且做到：
1). 不修改函数的源代码；
2). 函数的调用方式没有改变
我们来看这样一个装饰器，它的作用是记录一个函数的执行时间（func()是要执行的函数）

import  time

def timmer(func):
    def dec():
        start_time = time.time()
        func()
        stop_time = time.time()
        return stop_time-start_time
    return dec

它在具体使用时如下所示进行使用：

@timmer
def hello2():
    print "hello2......"
    time.sleep(2)

# hello2=timmer(hello2)
print hello2()
#其中@timmer的实质就是hello2=timmer(hello2)，我们把它叫做“语法糖“

运行结果