但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值

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

myabs = lambda x: -x if x < 0 else x
意思：如果x小于0 则返回-x 否则返回x

sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。请用functools.partial把这个复杂调用变成一个简单的函数：

参考代码：

import functools
sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper()))
print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

@performance只能打印秒，请给 @performace 增加一个参数，允许传入's'或'ms'：

参考代码：

import time
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return r
        return wrapper
    return perf_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

s是指list里的一个元素而不是list列表， map会遍历所有元素，所以s[0]并不是指'adam'个元素，而是元素'adam'里的第一个元素a

map（）函数是Python的内置高阶函数

map()函数的作用（函数，list）

并通过函数f依次作用在list的每个元素上

import time

def performance(f):

    def fn(*args, **kw):

        t1 = time.time()

        t2 = time.time()

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

        return f(*args, **kw)

    return fn

@performance

def factorial(n):

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

print factorial(10)

不用再定义一个r

def calc_prod(lst):

    def lazy_prod():

        def f(x, y):

            return x * y

        return reduce(f, lst)

    return lazy_prod

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

print f()

 line5 没有1也可以

请编写一个@performance，它可以打印出函数调用的时间。

• 计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。

• 参考代码:

  import time
  def performance(f):
      def fn(*args, **kw):
          t1 = time.time()
          r = f(*args, **kw)
          t2 = time.time()
          print 'call %s() in %fs' % (f.__name__, (t2 - t1))
          return r
      return fn
  
  @performance
  def factorial(n):
      return reduce(lambda x,y: x*y, range(1, n+1))
  print factorial(10)

利用匿名函数简化以下代码：

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

参考代码:

print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

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

f1, f2, f3 = count()

实际结果全部都是 9（请自己动手验证）。返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。

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

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

import math
def is_sqr(x):
    r = int(math.sqrt(x))
    return r*r==x
print filter(is_sqr, range(1, 101))

或者：

import math
def is_sqr(x):
    return math.sqrt(x) % 1.0 == 0
print filter(is_sqr, range(1, 101))