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

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

函数式: functional 一种编程范式。

函数式编程的特点:

1. 把计算视为函数而非指令
   

2. 纯函数式编程:不需要变量，没有变量，测试简单

3. 支持高阶函数，代码简洁
   

https://www.cnblogs.com/yaoxing365/p/9481877.html

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

get方法，用@property装饰，

set方法，用@score.setter装饰

像使用属性一样设置score

s.score = 60

1、__str__()用于显示给用户，而__repr__()用于显示给开发人员。str 最后一句必须是字符串格式

 def __str__(self):
        return '(Person: %s, %s)' % (self.name, self.gender)

__repr__ = __str__

2、对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()：升序：

def __cmp__(self, s):
        if self.name < s.name:
            return -1
        elif self.name > s.name:
            return 1
        else:
            return 0

3、__len__()，它返回元素的个数。

class Students(object):
    def __init__(self, *args):
        self.names = args
    def __len__(self):
        return len(self.names)

4、Rational类表示有理数加法减法乘法除法并约分

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  yuefen(self):

        x=self.p

        y=self.q

        while y!=0:

            god=x%y

            x=y

            y=god

        return Rational(self.p/x,self.q/x)

    def __str__(self):

        self=self.yuefen()

        return "(%s/%s)"%(self.p,self.q)

    __repr__ = __str__

2、

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]

1、

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 传入其他函数，就可以得到不同的返回值。

有点难记住

这里好难搞懂

def count():

    fs = []

    for i in range(1, 4):

        def f(i):

            return lambda : i**2   

        fs.append(f(i))

    return fs

for j in count():

    print(j())

打印出函数调用的时间

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)

顺序的比较

f.__name__是函数的名字，函数对象中有一个__name__属性用来保存函数的名字，这里的作用是加上前面的'call'组装打印出log信息

保护需要输出的函数名字

语法

reduce() 函数语法：

reduce(function, iterable[, initializer])

参数

• function -- 函数，有两个参数

• iterable -- 可迭代对象

• initializer -- 可选，初始参数

返回值

返回函数计算结果。

---------------

函数f计算积，

（（1*2）*3）*4=24