#使用map（）完成平方的计算

 def f(x):

     return x*x

 l = [1,2,3,4,5,6,7,8]

 print map(f, l)  #[1, 4, 9, 16, 25, 36, 49, 64]

请注意我们定义的函数f。当我们写f时，指的是函数对象本身，当我们写f(1)时，指的是调用f函数，并传入参数1，期待返回结果1。

因此，map()传入的第一个参数是f，即函数对象本身。

像map()函数这种能够接收函数作为参数的函数，称之为高阶函数（Higher-order function）。

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

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

 #使用reduce完成一个求和计算

 def add(x,y):

     return x+y

 print reduce(add ,l) #

 #使用mapreduce实现将数字字符串转换为整数

 def str2int(s):

     def fn(x, y):

         return x * 10 + y

     def char2num(s):

         return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

     return reduce(fn, map(char2num, s))

 print str2int('')

排序算法  

 #自定义平排序规则，对数据从大到小排序

 def myOrder(x , y):

     if x > y:

         return -1

     elif x< y:

         return 1

     else: return 0

 print sorted(l, myOrder)

函数作为返回值

 #一个求和函数，将函数作为返回值

 def laz_sum(*args):

     def sum():

         ax = 0

         for n in args:

             ax = ax + n

         return ax

     return sum

 ff = laz_sum(*l) #<function add at 0x021448B0>

 print ff() #

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

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

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

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

>>> f1==f2

False

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

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

def f(x):

    return x * x

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

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

。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x

>>> f

<function <lambda> at 0x10453d7d0>

>>> f(5)

25

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

def build(x, y):

    return lambda: x * x + y * y

 def log(func):

     def wrapper(*args,**kw):

         print '运行%s()方法:'% func.__name__

         return func(*args, **kw)

     return wrapper

 @log

 def now():

     print "2014-11-13"

 now() #调用

观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处。

把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：

>>> now.__name__

'wrapper'

因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

 import functools

 def log(func):

     @functools.wraps(func)

     def wrapper(*args, **kw):

         print 'call %s():' % func.__name__

         return func(*args, **kw)

     return wrapper

或者针对带参数的decorator：

 import functools

 def log(text):

     def decorator(func):

         @functools.wraps(func)

         def wrapper(*args, **kw):

             print '%s %s():' % (text, func.__name__)

             return func(*args, **kw)

         return wrapper

     return decorator

import functools是导入functools模块。模块的概念稍候讲解。现在，只需记住在定义wrapper()的前面加上@functools.wraps(func)即可。