作为闭包的返回函数不要引用任何循环变量，或者后续会发生变化的变量。

抽象呀，抽象

返回函数，仔细理解延迟计算。。。

math.sqrt()返回的是浮点数，注意别错了

reduce()函数用的时候能想起吗？

1、math.sqrt注意别错了。

2、函数作为参数传如时, 不需要带()

**kw在类中含有任意数量的参数

class Person(object):

    def __init__(self, name, gender, **kw):

        self.name=name

        self.gender=gender

        for k,v in kw.items():

            setattr(self,k,v)

p = Person('Bob', 'Male', age=18, course='Python')

print p.age

print p.course

python中reduce()函数reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。例如，编写一个f函数，接收x和y，返回x和y的和：def f(x, y):     return x + y 调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：先计算头两个元素：f(1, 3)，结果为4； 再把结果和第3个元素计算：f(4, 5)，结果为9； 再把结果和第4个元素计算：f(9, 7)，结果为16； 再把结果和第5个元素计算：f(16, 9)，结果为25； 由于没有更多的元素了，计算结束，返回结果25。 上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：reduce(f, [1, 3, 5, 7, 9], 100) 结果将变为125，因为第一轮计算是：计算初始值和第一个元素：f(100, 1)，结果为101。

写的有点复杂

class Fib(object):

    def __init__(self, num):
        self.list = []
        x = 0
        y = 1
        if num == 1:
            self.list.append(0)
        elif num == 2:
            self.list.append(1)
        else:
            self.list.append(x)
            self.list.append(y)
            for item in range(0, num-2):
               sum = x + y
               temp = y
               y = x + y
               x = temp
               self.list.append(sum)

    def __str__(self):
        return str(self.list)

    __repr__ = __str__
    def __len__(self):
       return len(self.list)

f = Fib(10)
print f
print len(f)

返回函数注意事项

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

函数定义要明确返回的是值还是函数

返回的如果是值，调用f(函数)名称，能起到延迟加载的作用，f()则是返回值；

若返回的是函数，f()返回的是函数，本身就是延迟加载；a=f();a()才是真正获得值

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中：

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    wrapper.__name__ = f.__name__
    wrapper.__doc__ = f.__doc__
    return wrapper

这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务：

，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：

也可能改变原函数的参数名，因为新函数的参数名始终是 'x'，原函数定义的参数名不一定叫 'x'。

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)

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
print test()