map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

这题答案不会，是参考代码

import time

def performance(f):

    def fn(*args,**kw):

        t1 = time.time()

        r = f(*args,**kw)

        t2 = time.time()

        t = t2 -t1

        #print 'call' + f._name_ + 'in'

        print 'call %s() in %fs' % (f.__name__, (t2 - t1))

        print t

        return r 

    return fn

@performance

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

看不懂

因为none无法用strip，就是为了避免none被strip报错，所以才先s，none先判断false ，and后面就不会执行了。

取巧的用法，这么写相当于免了你去判断s是不是none，以及是none之后的后处理

要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

调用装饰器时，有点类似复合函数的调用：

g1 = new_fn(f1)

print g1(5)

当然我们将复合函数命名为原函数时，就可以彻底抹去了f1的原始定义。

 f1 = new_fn(f1)

print f1(5)

这也是装饰器的含义。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写f = decorate(f) 这样的代码。

高阶函数

可以接收函数作为参数

可以返回函数

所以可以接收一个函数，对其包装，然后返回一个新函数

cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

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

但可以有多个函数参数。

//自定义比较函数
def MyCmp(s1,s2):   
     s1 = s1.upper()   
     s2 = s2.upper()    
     if s1 < s2:       
         return -1    
     if s1 > s2:        
          return 1   
     return 0

//偏函数       
sorted_ignore_case = functools.partial(sorted, cmp=MyCmp )

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

******************************************

**偏函数的作用是简化原函数的参数个数，

通过调用functools.partial("原函数名","原函数的参数默认值")工具

获得原函数的偏函数,

举例：

这里的sorted函数为原函数，原型为

sorted(iterable, cmp)

他一般需要两个参数1为集合，参数2(cmp)为：自定义比较函数，所以我们利用自定义比较函数的值

在functools.partial中设置参数cmp的默认值，然后得到偏函数sorted_ignore_case，

这时由于参数2已被默认设置，调用sorted_ignore_case时只传一个参数list集合即可

这也是我疑惑的，f1,f2,f3= count()

其实会根据函数返回不同的值而代表不同的含义的

最后部分的 print f1（）, f2（）, f3（） 改为print f1, f2, f3，原因是因为当前没有函数，只是函数值.

正确使用闭包的关键在于要确保引用的局部变量在函数返回后不能变。

希望一次返回3个函数的关键在于，确保引用的是函数值而不是函数（指的是一个变量，在python中显示是一个地址？）

所以出题的目的在于再次强调函数变量与函数值的区别，在表达上体现为，f ----> 变量， f（）---->函数值。

引用变量时只会返回循环的最终结果。（说循环也不够精准，应该是函数的最终返回值）

在函数内定义函数的另一种作用（除了延迟计算）是防止其他代码调用内部函数。

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包。

要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。例子：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)  #函数内部还调用了函数f吗？
    return fs 

f1, f2, f3 = count()

def calc_prod(lst):

    L = lst

    def my_prod():   #这个是为了仅仅返回函数，所以就不需要设置参数吗？

        def f(x,y):

            return x*y

        return reduce(f,L) #可是这个函数是返回一个数的，这个数是reduce函数调用的结果，调用函数时函数f仅仅作为一个变量存在。

    return my_prod  #这里就体现延迟计算的功能了

f = calc_prod([1, 2, 3, 4])

print f()

有点抽象，为什么，函数内定义函数my_prod时没有参数？

为什么有的调用函数时用的是变量形式，而有的是要调用函数形式？

所谓“延迟计算”，是指定义的函数中带有的函数必须进行调用时，才计算出结果。

那么我们在后续代码中可以根据需要来决定到底要不要调用该函数。