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

reduce()还可以接收第3个可选参数，作为计算的初始值。

reduce(f, [1, 3, 5, 7, 9], 100)

结果将变为125

（（（（100+1）+3）+5）+7）+9

python3下的map()函数返回类型为iterators，不再是list

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

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

输出结果：

[1, 4, 9, 10, 25, 36, 49, 64, 81]

注意：map()函数不改变原有的 list，而是返回一个新的 list。

python把函数作为参数

在2.1小节中，我们讲了高阶函数的概念，并编写了一个简单的高阶函数：

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

如果传入abs作为参数f的值：

add(-5, 9, abs)

根据函数的定义，函数执行的代码实际上是：

abs(-5) + abs(9)

由于参数 x, y 和 f 都可以任意传入，如果 f 传入其他函数，就可以得到不同的返回值。

1.函数
    一：函数作为参数
        def add( x, y, f):
            return f(x)+f(y);
        传入abs作为参数的值，add(-5, 9, abs)  //abs(-5) + abs(9)
        由于参数 x, y 和 f 都可以任意传入，如果 f 传入其他函数，就可以得到不同的返回值。
    二：python内置函数
        1.map() 
          map()是Python内置的高阶函数,它接收一个函数f和一个list并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。
        例如:
        def f(x):
            return x*x;
        print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])  
        // [1, 4, 9, 10, 25, 36, 49, 64, 81]
        注意：map()不改变原有的list，而是返回一个新的list，
             利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。
        2.reduce()
            reduce()函数和map()函数类似，传入两个参数，函数f和list，但函数f必须接收两个参数。
            例如：
            def f(x, y):
                return x + y；
             print reduce(f, [1, 3, 5, 7, 9]);  //25
            计算过程：
                先计算头两个元素：f(1, 3)，结果为4；
                再把结果和第3个元素计算：f(4, 5)，结果为9；
                再把结果和第4个元素计算：f(9, 7)，结果为16；
                再把结果和第5个元素计算：f(16, 9)，结果为25；
                由于没有更多的元素了，计算结束，返回结果25。
        3.filter() 
            filter()函数接收一个函数 f 和一个list，对每个元素进行判断，返回 True或 False，
            filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
            例如，删除 None 或者空字符串：
            def is_not_empty(s):
                return s and len(s.strip()) > 0
            filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])  
            //['test', 'str', 'END']
        4.sorted()
            sorted(iterable[,cmp,[,key[,reverse=True]]])
            作用：返回一个经过排序的列表。
            第一个参数是一个iterable，返回值是一个对iterable中元素进行排序后的列表(list)。
            可选的参数有三个，cmp、key和reverse。
            1)cmp指定一个定制的比较函数，这个函数接收两个参数（iterable的元素），
              比较函数的定义是，传入两个待比较的元素 x, y，
              如果 x 应该排在 y 的前面，返回 -1，
              如果 x 应该排在 y 的后面，返回 1。
              如果 x 和 y 相等，返回 0。
            2)key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None。
            3)reverse是一个布尔值。如果设置为True，列表元素将被倒序排列。
              key参数的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。
              对复杂对象的比较通常是使用对象的切片作为关键字。
              运用该方法：
                  一：可定制一个函数传入cmp（两个参数）
                    def reversed_cmp(x, y):
                        if x > y:
                            return -1；
                        if x < y:
                            return 1；
                        return 0；
                     print sorted([36, 5, 12, 9, 21], reversed_cmp)；  
                     // 传入cmp形参：[36, 21, 12, 9, 5]
                   二：定制函数传入key（一个参数）
                     def cmp_ignore_case(t):
                         return t.lower();
                     print sorted(['bob', 'about', 'Zoo', 'Credit'], key=cmp_ignore_case)  
                     //传入key形参：['about', 'bob', 'Credit', 'Zoo']
                   三：默认设置sorted()
                     print  sorted([36, 5, 12, 9, 21])；
                     //sorted()也可进行排序，字符串默认按照ASCII大小来比较：[5, 9, 12, 21, 36]

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'])

sorted_ignore_case1 = functools.partial(sorted,key=lambda s1: s1.upper())

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

sorted_ignore_case2 = functools.partial(sorted,key=str.lower)

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

**kw的作用是保存字典，通过iteritems()产生迭代器，通过迭代获取内容，通过for循环，可以每次获取到一个键值对

当然，本文章的主题并不是讲默认参数，而是另外一种达到可变参数 (Variable Argument) 的方法：使用*args和**kwargs语法。其中，*args是可变的positional arguments列表，**kwargs是可变的keyword arguments列表。并且，*args必须位于**kwargs之前，因为positional arguments必须位于keyword arguments之前。

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

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

f.__name__获取函数名

functools.partial 创建偏函数
例如：int2 = functools.partial(int, base=2)

map 可以多个参数，reduce()必须两个参数

def count():

    fs=[]

    for i in range(1,4):

        def f():

            return i*i

        fs.append(f())

    return fs

f1,f2,f3 = count()

print f1,f2,f3

注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)
    #def __div__(self, r):
    #    return Rational(self.p * r.q, self.q * r.p)
    def __str__(self):
        g = gcd(self.p, self.q)
        return '%s/%s' % (self.p / g, self.q / g)
    def __truediv__(self,r):
        return Rational(self.p * r.q, self.q * r.p)

    __repr__ = __str__

r1 = Rational(1, 2)
r2 = Rational(1, 4)
print(r1 + r2)
print(r1 - r2)
print(r1 * r2)
print(r1 / r2)

python3中要用“/”要自定义__turediv__（a,b）用“//”要定义__floordiv__（a,b）方法