Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f():
    print 'call f()...'    # 定义函数g:
    def g():
        print 'call g()...'    # 返回函数g:
    return g

仔细观察上面的函数定义，我们在函数 f 内部又定义了一个函数 g。由于函数 g 也是一个对象，函数名 g 就是指向函数 g 的变量，所以，最外层函数 f 可以返回变量 g，也就是函数 g 本身。

调用函数 f，我们会得到 f 返回的一个函数：

>>> x = f()   # 调用f()call f()...
>>> x   # 变量x是f()返回的函数：<function g at 0x1037bf320>
>>> x()   # x指向函数，因此可以调用call g()...   # 调用x()就是执行g()函数定义的代码

请注意区分返回函数和返回值：

def myabs():
    return abs   # 返回函数def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值

返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：

def calc_sum(lst):
    return sum(lst)

调用calc_sum()函数时，将立刻计算并得到结果：

>>> calc_sum([1, 2, 3, 4])
10

但是，如果返回一个函数，就可以“延迟计算”：

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

# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>

# 对返回的函数进行调用时，才计算出结果:

>>> f()
10

由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

这节懵逼的

Python 中使用装饰器对在运行期对函数进行一些外部功能的扩展。但是在使用过程中，由于装饰器的加入导致解释器认为函数本身发生了改变，在某些情况下——比如测试时——会导致一些问题。Python 通过 functool.wraps 为我们解决了这个问题：在编写装饰器时，在实现前加入 @functools.wraps(func) 可以保证装饰器不会对被装饰函数造成影响。

reduce的用法

__doc__，双下划线。<p>每个对象都会有一个__doc__属性，用于描述该对象的作用。在一个模块被import时，其文件中的某些特殊的字符串会被python解释器保存在相应对象的__doc__属性中。比如，一个模块有模块的__doc__，一个class或function也有其对应的__doc__属性。在python中，一个模块其实就是一个.py文件。在文件中特殊的地方书写的字符串就是所谓的docstrings，就是将被放到__doc__的内容。这个“特殊的地方”包括：</p><p>1. 一个文件任何一条可执行的代码之前  #模块的__doc__</p><p>2. 一个类，在类定义语句后，任何可执行代码前#类的__doc__</p><p>3. 一个函数，在函数定义语句后，任何可执行代码前#函数的__doc__</p>

函数签名就是一个函数的标识，作用于函数重载中应用很多，包括了函数名和参数个数与类型，这里把函数的参数类型和个数都变化了，所以得不到原函数的参数信息

这一节还不太理解

闭包

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变

最外层def的函数先执行，内部def的函数不调用则不执行，但凡调用，则以当前状态的传入参数。即

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()

这些代码当中，运行时就从def count()的内容开始执行，但没有执行内部的def f()中的内容，因为没有外部调用。其中分三次放入fs的f都是一样的，不受 i 变化的影响。只有最后f1，f2，f3才调用def f()中的内容，此时，i 的值已经是3了。

解决思路1：直接在def count()中def ()后直接调用f()，结果就是：

解决思路2：使用闭包，f()中再def一个g()，f()往g()中传入参数，返回g不带括号，这里通过对f()传入的参数不同最终返回的结果也不同。

函数的默认参数不可为可变数据对象（既内存id，type不变时，value可变），如list ,dict，set，在对其进行内容方法操作后，其值会改变，如l.append(x)/pop()。

不可变对象有int,float,str,tuple,unicode(3中去除），对其施加方法操作后其值不变，如s.replace('x','y')。

i和j就是实参和形参的关系

 def f(j):
            def g():
                return j*j
            return g
        r=f(i)
        fs.append(r)
    return fs
不太理解

1.高阶函数：函数调用函数
2.闭包 : 外层是带参数的函数，内层函数调用了外层的参数
3.装饰器 ：就是高阶函数的应用，把函数做参数调用，包装一下，再返回函数
4.带参数的装饰器:就是外面又套了一层的函数

log_decorator = log('Debug')
log = log_decorator(log)

g()是用来进行运算的，f()()则是调用g()。

主要通过f()往g()送入参数，再执行g()。

即，每次外部调用f()()，实际上执行的是g()

不对传入参数进行改变，其他怎么变化都行，最终实现对比。