8 python高阶函数、返回函数、装饰器

################################################################################
##------------- 高阶函数  ----------------------------------------------------

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
高阶函数：
    即是函数的形参，是用来接受函数的。这样的函数叫做高阶函数。

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
函数对象有一个__name__属性，可以拿到函数的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

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

例如：
一个最简单的高阶函数：

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


##--------------- 高阶函数之 map()和reduce()函数----------------------------------------------
map说明：
    map()函数接收两个参数，一个是函数，一个是 Iterable
    map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

例如：
def f(x):
    return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print list(r)


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

例如：
from functools import reduce
def add(x, y):
    return x + y

print reduce(add, [1, 3, 5, 7, 9])


##---------------- 高阶函数之 sorted() 排序算法函数 ---------------------------------------------------、

说明：
但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

例如1：
    python内置的sorted()函数就可以对list进行排序：

print sorted([36, 5, -12, 9, -21])
结果：[-21, -12, 5, 9, 36]


例如2：
    此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
    key指定的函数将作用于list的每一个元素上，
    并根据key函数返回的结果进行排序。对比原始的list和经过key=abs处理过的list：

print sorted([36, 5, -12, 9, -21], key=abs)
结果：[5, 9, -12, -21, 36]


##---------------- 高阶函数之 filter() 函数----------------------------------------------------

filter说明：
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如：
def is_odd(n):
    return n % 2 == 1

print list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]


##-----------------返回函数 （函数作为返回值）------------------------------------------------

返回函数说明：
    高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。


我们来实现一个可变参数的求和。通常情况下，求和的函数是这样定义的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax


但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？可以不返回求和的结果，而是返回求和的函数：

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)
 print f()                    --调用函数f时，才真正计算求和的结果：

结果：25

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

##------------- 装饰器函数（即形参是函数的返回函数）  ----------------------------------------------------

装饰器的定义
本质是函数。（装饰其他函数） 它可以让其他函数在不需要做任何代码变动的前提下增加额外功能。

装饰器的重要性
比如：已经上线的生产环境上有100个函数，需要增加新功能，新增功能不能修改源代码，也不能修改原函数的,这个时候就用到了装饰器。

装饰器经常有切面需求的场景，
    比如：插入日志，性能测试，事务处理，缓存，权限校验等场景。
    装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。 
    概括的讲，装饰的作用就是为已经存在的对象添加额外的功能。

说明：
现在，假设我们要增强now()函数的功能，
比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，
这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，

装饰器函数：
    其实本质就是一个返回函数，只不过是此返回函数本身又是高阶函数。
    即 即是高阶函数（参数是函数）又是返回函数（返回值是函数）

装饰器函数的原理：
    就是利用返回函数的作用，将一个函数包在返回函数里面，
    1，第一次调用返回函数，并且将需要被装饰的函数传参进去
    2，第二次调用返回值，就是调用了内部函数，就是调用了被装饰过后的第一次传参进去的函数（在这次调用时可以加上其它功能的代码运行）
    
##装饰器的经典应用
import os
import sys
import re
import time

# 这里的timer就是一个装饰器   ，
#func形参就是用来接受需要被装饰的函数，
#后面test1就是需要被装饰的函数，
#装饰的效果就是在被装饰的函数运行前后加上了start_time和end_time
def timer(func):
    def deco(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        print("the func [%s] run time is %s" %(func.__name__,end_time-start_time))
    return deco

# 装饰器的调用，将函数返回值赋值给test1(注意：！！ 装饰器，在装饰的时候就已经调用了第一次，即已经装饰好了，后面直接再第二次调用函数即可)
# test1 = timer(test1)
@timer  
def test1():
    time.sleep(3)
    print("in the test1")


##test1函数调用（此时的test1已经不再是之前定义的，而是timer 装饰器返回的一个函数）
test1()

########################装饰器之wraps###################################################################
#coding=utf-8  
# -*- coding=utf-8 -*-   
from functools import wraps     
def my_decorator(func):  
    #@wraps(func)  
    def wrapper(*args, **kwargs):  
        '''''decorator'''  
        print('Calling decorated function...')  
        return func(*args, **kwargs)  
    return wrapper    
 
@my_decorator   
def example():  
    """Docstring"""   
    print('Called example function')  
print(example.__name__, example.__doc__)

例如：
    以上代码，
    没有@wraps(func)此句时：
    >>('wrapper', 'decorator')
    有@wraps(func)时：
    >>('example', 'Docstring')

说明：
    __name__   属性是类或函数的名字属性
    __doc__   属性，是类、函数、文件中特殊位置的字符串
    1. 一个文件任何一条可执行的代码之前  #模块的__doc__

    2. 一个类，在类定义语句后，任何可执行代码前  #类的__doc__

    3. 一个函数，在函数定义语句后，任何可执行代码前  #函数的__doc__

作用：
Python装饰器（decorator）在实现的时候，
被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变），
为了不影响，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。
写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和docstring。



############### 基于python的-@property与@setter装饰器 ####################################
此装饰器所添加的功能：
property可以将方法转化成属性。
所以一般用于类中，写在类中方法上面，（即此装饰器装饰了这个方法，后面调用这个方法就可以用属性的方式来调用方法）

class People(object):  
    @property  
    def getAge(self):  
        return self.age  
    @age.setter  
    def setAge(self, age):  
        if age<0:  
            raise ValueError('age error!')  
        else:  
        self.age = age 

在getter上加上property装饰器之后就可以直接以这种方式people.age获取age的值，settler的做法差不多只是装饰器的写法不一致而已将【变量名】
.setter写在setter上面即可完成，从此设置age不用使用setter那么麻烦了，可以直接使用people.age=60这样的写法啦