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

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

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

def f(j):
    def g():
        return j*j
    return g

它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。

在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。

import time

def performance(unit): # 接受 @performance('ms')中的str 'ms'

    def perf_decorator(factor): # 正常的

        def decorator(*arg,**args): # 

            t1 = time.time()

            r = factor(*arg,**args)

            t2 = time.time()

            t = (t2 - t1)*1000 if unit == 'ms' else (t2 - t1)

            print 'call %s() in %f %s'%(factor.__name__,t,unit)

            return r

        return decorator

    return perf_decorator

# 带参装饰器 理解如下

# perf_decorator = performance('ms')  

# factorial = decorator(factorial)

# 简写为 factorial = performance('ms')(factorial)

@performance('ms')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

'''

带参数的装饰器函数其实就是在原来的基础(装饰器)上添加外层函数，又返回内层的装饰器函数而已.

带参的 @log('xxx') 函数首先返回一个decorator函数，再让这个函数接收decorator函数接收

factorial 并返回函数。

'''

首字母大写函数：capitalize（）

map()函数：map（函数，list）

接收一个函数f和一个list，并通过把函数f一次作用在list的每一个元素上，返回一个新的list

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

首字母大写函数：capitalized（）

利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list：

def format_name(s):

    return s.capitalize()

print map(format_name, ['adam', 'LISA', 'barT'])

reduce（）函数：reduce（函数，list）

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

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

利用recude()来求积：

def prod(x, y):

    return x*y

print reduce(prod, [2, 4, 5, 7, 12])

filter（）函数：filter（函数，list）

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

利用filter()过滤出1~100中平方根是整数的数:

import math

def is_sqr(x):

    r = int(math.sqrt(x))

    return x == r*r

print filter(is_sqr, range(1, 101))

自定义排序函数：sorted（）函数：

>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]

sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

利用sorted()高阶函数，实现忽略大小写排序的算法：

def cmp_ignore_case(s1, s2):
    u1 = s1.upper()
    u2 = s2.upper()
    if u1 < u2:
        return -1
    if u1 > u2:
        return 1
    return 0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

可是这么做有什么意义呢？

在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数

 from functools import reduce

继承父类 ，要记得初始化父类实例，super(Student,self).__init__(name,gender)

在类中定义__cmp__函数

Python的特殊方法有以下特点：

特殊方法定义在class中；

不需要直接调用；

Python的某些函数或操作符会调用对应的特殊方法。

返回函数：：

abs 是一个内置函数 不在math包内

sqrt 是math 包内的一个函数

and 从左到右扫描，返回第一个为假的表达式值，无假值则返回最后一个表达式值。

or 从左到右扫描，返回第一个为真的表达式值，无真值则返回最后一个表达式值。

filter()过滤函数

在Python中，函数也是对象，对象和函数的区别并不显著。

在计算时，如果 两个都是整数则计算结果就是整数 ，有一个是浮点数则向更高级的类型转换，所以把整数的除号删去一个也是可以的，但在返回值为浮点数部分需要加一个浮点数，把原来的整数变为浮点数，//表示整除，但结果的数据类型根据计算的数字决定，所以运行结果是3.5是有问题的，测试时，7//2，结果是3，并不是3.5，7.0//2，结果为3.0